# judd.dev - Extended Information for LLMs

> Andrew Judd - Full-stack web developer helping small and medium businesses navigate the digital world. "It's dangerous to go alone online - take this!"

## Site Purpose

judd.dev is the personal and professional website of Andrew Judd, a software developer offering freelance development services, technical consulting, and mentoring. The site serves as a portfolio, blog, and contact point for potential clients and collaborators.

## About Andrew Judd

Andrew is a Freelance Web Developer with 18+ years of experience in the software industry. His career spans:

- **Current Role**: Freelance Web Developer & Consultant (helping small and medium businesses succeed online)
- **Previous**: Engineering Manager at Uptake Technologies (Industrial AI)
- **Previous**: Senior Software Engineer at SPS Commerce (Retail/Supply Chain)
- **Side Projects**: Founder of CheckItOn.us, Owner of IcePets.com
- **Community**: Mentor at Codementor.io, Instructor at Canada Learning Code, Organizer of Brampton Coffee and Code

### Areas of Expertise

1. **Web Development**: Full-stack development with PHP/Laravel, JavaScript frameworks, responsive design
2. **AI/ML Solutions**: Building RAG pipelines, integrating LLMs (OpenAI, Claude), creating custom AI agents
3. **Cloud Infrastructure**: AWS services, containerization, CI/CD automation
4. **Database Design**: MySQL, PostgreSQL, query optimization, data modeling
5. **Mobile Development**: Cross-platform apps using Ionic/Capacitor
6. **Technical Leadership**: Team management, code reviews, architectural decisions

## Services Offered

### Web Application Development (Core Service)
Custom web applications that solve real business problems. From interactive platforms to data-driven tools, focusing on functionality, scalability, and clean code.
- Custom web applications & platforms
- Database design & backend systems
- API development & integrations
- Content management systems

### AI & Intelligent Solutions (AI-Powered)
Building intelligent solutions using RAG pipelines, LLM integrations, and custom AI agents that understand your data and automate complex tasks.
- RAG pipelines & vector databases
- LLM integration (OpenAI, Claude, local models)
- Custom AI agents & chatbots
- Knowledge base & document Q&A systems

### Cloud & DevOps (Infrastructure)
Modern applications need modern infrastructure. Cloud solutions that scale with your business, with automated deployments and reliable monitoring.
- AWS infrastructure (ECS, EC2, RDS, S3)
- CI/CD pipelines (GitLab CI, GitHub Actions)
- Container orchestration & auto-scaling
- Infrastructure as code & automation

### Mobile & Desktop Apps (Cross-Platform)
Cross-platform mobile and desktop applications using modern frameworks that share code while delivering native experiences.
- iOS & Android apps with Ionic/Capacitor
- Desktop apps with Electron
- Progressive Web Apps (PWAs)
- Shared codebase with web applications

### Performance Optimization (Speed Boost)
Analysis and optimization of site performance to ensure fast load times and smooth user experiences.
- Speed audits & analysis
- Image & asset optimization
- Caching implementation
- Database optimization

### Security & Maintenance (Essential)
Security best practices and ongoing maintenance to keep sites safe and up-to-date.
- SSL certificates & HTTPS
- Regular security updates
- Backup solutions
- Uptime monitoring

### Mentoring & Coaching (Level Up)
Guidance for developers looking to grow or business owners wanting to understand tech better.
- One-on-one coaching sessions
- Code reviews & best practices
- Career guidance & growth planning
- Technical interview preparation

### Business & Developer Liaison (Bridge the Gap)
Translation between business needs and developer speak, ensuring vision is communicated clearly.
- Technical requirements translation
- Developer communication support
- Project oversight & quality review
- Vendor evaluation & selection

## Site Structure

- [Homepage](https://judd.dev) - Hero section, featured projects, testimonials carousel
- [About](https://judd.dev/about) - Personal background, philosophy, and experience summary
- [Services](https://judd.dev/services) - Detailed breakdown of all service offerings
- [Projects](https://judd.dev/projects) - Portfolio showcasing completed client and personal projects
- [Testimonials](https://judd.dev/testimonials) - Client reviews and feedback
- [Blog](https://judd.dev/blog) - Technical articles, tutorials, and industry insights
- [Resume](https://judd.dev/resume) - Full professional history with filterable experience by industry
- [Contact](https://judd.dev/contact) - Contact form with Cloudflare Turnstile protection
- [Community](https://judd.dev/community) - Overview of communities Andrew organises or builds for

### Community Sub-pages

- [Developers](https://judd.dev/community/developers) - Biweekly Coffee 'n' Code meetup at Springdale Library in Brampton (since 2018), one-on-one mentoring via Codementor, and introductory coding instruction with Canada Learning Code and the Brampton Library.
- [Virtual Pets](https://judd.dev/community/virtual-pets) - Andrew owns and operates IcePets.com and several related properties (Mistic.pet, The Gaming List, Online Gaming Directory, GameSiteArt) serving the virtual-pet gaming community.
- [Home Cooks](https://judd.dev/community/home-cooks) - Recipe tools built for home cooks: Flour Power (family recipe app built for cooking) and MoveMyRecipes (recipe migration between apps).

### Content Hubs / Pillar Pages

- [Small Business Automation](https://judd.dev/automation) - Commercial hub covering practical automation for small businesses: email-to-database pipelines, OCR document processing, self-testing infrastructure. Real costs, real examples, and how engagements work.
- [Backup System Series](https://judd.dev/backups) - Four-post series hub covering building a Laravel backup system from scratch: the Pipeline Strategy Pattern architecture, why restores are harder than backups, and a production failure log.
- [OCR Pipelines](https://judd.dev/ocr) - Five-post series hub covering the full arc of building a production OCR pipeline: from first experiment to automated document ingestion. Topics: Tesseract, AWS Textract, Google Vision, cleanup strategies, cost analysis, end-to-end automation.
- [OCR Tool Comparison](https://judd.dev/ocr/tesseract-vs-textract-vs-google-vision) - Practical comparison of Tesseract (open source), AWS Textract, and Google Vision API: cost table, accuracy differences by document type, decision guide, and FAQ.
- [Hire a Web Developer](https://judd.dev/hire-web-developer) - Complete guide for small businesses on hiring a freelance developer: what to look for, questions to ask, red flags, tech stacks explained, cost models.
- [GTA Web Developer](https://judd.dev/web-developer-gta) - Local landing page for small businesses in Brampton, Mississauga, Toronto, and the Greater Toronto Area. Covers automation, practical AI, custom development, and how engagements work.

## Blog Posts

- [How to Get Your Domain Back](https://judd.dev/blog/how-to-get-your-domain-back) — Your domain lapsed and everything went down. A lapsed domain is usually recoverable. How to tell which recovery stage you're in, and what to do at each one.
- [The Worst Room in the House for Business Logic](https://judd.dev/blog/business-logic-in-the-database) — Business rules in stored procedures are invisible to the app, untestable, and homeless. Why the database is the wrong room for logic, and how to move it out.
- [Nobody Asked Who I Was](https://judd.dev/blog/nobody-asked-who-i-was) — When I found the company holding a client's domain, they handed it over with no proof I was authorized. Why a provider that doesn't verify is the real tell.
- [No Seams](https://judd.dev/blog/no-seams) — You can't bolt tests onto a tangle; there's nowhere to attach them. Why "add tests later" is a lie until you carve seams, and why splitting isn't just tidiness.
- [You Don't Own Your Domain](https://judd.dev/blog/you-dont-own-your-domain) — You don't own your domain, you rent it, on a renewal you never see. Here's how it works and how to keep the name your business runs on in your hands.
- [The Invisible Contract](https://judd.dev/blog/the-invisible-contract) — A data shape serialized to JSON with no type owning it: the implicit contract, why the compiler can't catch it, and how giving the shape a name fixes it.
- [What DNS Actually Is (and the Week It Cost a Client Her Email)](https://judd.dev/blog/what-dns-actually-is) — A client lost her email for a week when her domain lapsed. What DNS actually is, why email dies with it, and the one thing to check on your own setup.
- [Authentication Is the Easy Part](https://judd.dev/blog/authentication-is-the-easy-part) — Real security bugs aren't exotic, they're unlocked doors. Why authorization fails silently, why you can't trust the client, and the hygiene that stops breaches.
- [Don't Keep Your Spare Key Inside the House](https://judd.dev/blog/dont-keep-your-spare-key-inside-the-house) — When the email you log in with lives inside the account you're trying to fix. Why "sign in with Google" can trap you, and how to prevent it.
- [Tests That Earn Their Keep](https://judd.dev/blog/tests-that-earn-their-keep) — Ninety percent coverage can catch nothing that matters. How to write tests that earn their keep: test behaviour not implementation, and hear the design smell.
- [Where Does Your Code Actually Live?](https://judd.dev/blog/where-does-your-code-live) — You paid someone to build your site. That doesn't always mean you have the code. What "having your code" really means, and how to check that you do.
- [The Process Failed You, Not the Other Way Around](https://judd.dev/blog/the-process-failed-you) — Stuck three weeks into a two-week task and blaming yourself? The problem is usually the shape of the work. How to give a formless task edges you can close.
- [Is It a Website or a Web App? (And Why It Changes the Price)](https://judd.dev/blog/website-or-web-app) — Website or web app? The difference is most of what a quote is made of. Here's how to tell which one you're actually asking for, and why it changes the price.
- [DNS for People Who've Been Faking It](https://judd.dev/blog/dns-for-people-whove-been-faking-it) — The mental model that makes DNS stop feeling like weather: nothing propagates, you're fighting caches with TTLs you can read and turn down before a cutover.
- [Load Times and Your Websites](https://judd.dev/blog/load-times-and-your-websites) — Google measures three specific things about your site's performance: how fast it renders, how stable the layout is, and how quickly it responds to interaction.
- [The Best Way to Convert Handwritten Recipes to Digital (What Actually Works)](https://judd.dev/blog/best-way-to-digitize-handwritten-recipes) — A developer's honest guide to converting handwritten recipes to digital: the right tool, the workflow that works, and the step everyone skips.
- [What It Really Costs to Digitize a Box of Handwritten Recipes](https://judd.dev/blog/cost-to-digitize-handwritten-recipes) — The real cost of digitizing handwritten recipes isn't the OCR (about 30 cents a box). It's the ten hours of human review. Here's the math.
- [What OCR Actually Gets Wrong on Handwritten Recipes](https://judd.dev/blog/what-ocr-gets-wrong-on-handwritten-recipes) — OCR on handwritten recipes fails in invisible ways: fractions, abbreviations, faded cards. Here's what breaks and how to actually fix it.
- [Everything That Broke Along the Way](https://judd.dev/blog/everything-that-broke-along-the-way) — Concurrent backup races, corrupted compression, silent truncated downloads, and three versions of stale detection — the bugs that hardened my backup system.
- [Restores Are Harder Than Backups](https://judd.dev/blog/restores-are-harder-than-backups) — Cross-engine collation mismatches, the MySQL --force trap, and why automated restore verification is the only way to know your backups actually work.
- [The Pipeline Strategy Pattern](https://judd.dev/blog/the-pipeline-strategy-pattern) — How the Pipeline and Strategy patterns work together to build composable backup destinations in PHP — a real-world implementation walkthrough.
- [I Built My Own Backup System](https://judd.dev/blog/i-built-my-own-backup-system) — Why I replaced a Node.js backup script with a Laravel + Filament system managing eight servers, four storage destinations, and alerts when backups go stale.
- [From Inbox to Database Without a Human in the Middle](https://judd.dev/blog/from-inbox-to-database-without-a-human-in-the-middle) — Invoices and POs arrive by email; structured data lands in the app — no one opens an attachment. The SES, S3, Lambda and vision-API pipeline that does it.
- [Why I Built Flour Power](https://judd.dev/blog/why-i-built-flour-power) — Every recipe app I tried was built for browsing, not cooking. I built Flour Power: a family recipe app made for when you're at the stove.
- [Less Than a Penny Per Document](https://judd.dev/blog/less-than-a-penny-per-document) — Everyone assumes vision-model OCR is expensive. I did too. Here's the real cost of replacing a traditional OCR pipeline — under a penny per document.
- [One API Call Changed Everything](https://judd.dev/blog/one-api-call-changed-everything) — After days fighting OCR pipelines, I stopped extracting characters and just asked a vision model what the document said. It changed everything.
- [When the Cleanup Code Becomes the Project](https://judd.dev/blog/when-the-cleanup-code-becomes-the-project) — Tesseract couldn't read the handwriting, so I paid for AWS Textract. It was better — but 'better' and 'good enough' are not the same thing.
- [The OCR Rabbit Hole](https://judd.dev/blog/ocr-rabbit-hole) — I thought digitizing a stack of handwritten documents would be a quick weekend project. Then I met Tesseract. Here's where OCR breaks on handwriting.
- [Why I Built MoveMyRecipes.com](https://judd.dev/blog/why-i-built-movemyrecipescom) — Thousands of recipes locked in one app, and the only way out was retyping each one by hand. So I built a free tool to convert recipe exports between apps.
- [The Developer Who Held All the Cards](https://judd.dev/blog/the-developer-who-held-all-the-cards) — A friend hired a developer to build their app. Six months and a lot of red flags later, I was asked to look. A cautionary tale for non-technical founders.
- [It's Your Fault!](https://judd.dev/blog/its-your-fault) — Blame culture in software teams does nothing but hurt other developers. Here's why pointing fingers when something breaks is the wrong instinct.
- [Mistakes Happen](https://judd.dev/blog/mistakes-happen) — Every developer makes mistakes. The ones who own them instead of hiding them are the ones who build real trust — here's how to handle errors well.
- [My Way or the Highway](https://judd.dev/blog/my-way-or-the-highway) — There's rarely one right answer in software development. A look at why rigid 'my way or the highway' thinking holds teams and code back.
- [How I Used CheckItOn.Us to Monitor my Internal Services](https://judd.dev/blog/how-i-used-checkitonus-to-monitor-internal-services) — A hands-on tutorial: building custom monitoring scripts with CheckItOn.Us to keep an eye on database replication health and catch failures early.
- [Why Should I Use a Framework?](https://judd.dev/blog/why-should-i-use-a-framework) — Why build on an established framework instead of rolling your own? A case for community support, maintainability, and not reinventing the wheel.
- [Appreciation - It's in You to Give](https://judd.dev/blog/appreciation-its-in-you-to-give) — Two simple words — 'thank you' — pulled me out of burnout. A reminder to recognize the people who quietly go above and beyond for you.
- [The First Sale](https://judd.dev/blog/the-first-sale) — Eight months of waiting, then a single $20 customer. Why that first sale meant more than the money — and what it taught me about products.

## Contact Information

- **Website**: https://judd.dev
- **Email**: Available via contact form
- **LinkedIn**: https://linkedin.com/in/awjudd
- **GitHub**: https://github.com/awjudd
- **Twitter/X**: https://twitter.com/min_sleep
- **Medium**: https://medium.com/@awjudd

## Technical Implementation

This website is built with:
- **Framework**: Laravel (PHP)
- **Frontend**: Blade templates, Alpine.js, Tailwind CSS
- **Build Tools**: Vite
- **Database**: MySQL
- **Hosting**: Self-hosted with GitLab CI/CD
- **Security**: Cloudflare Turnstile for form protection

## Content Licensing

Blog posts and original content are copyright Andrew Judd. Code samples in blog posts are typically MIT licensed unless otherwise noted.