Blog
Writing about systems that survive production.
Architecture decisions, performance work, AI integration patterns, and engineering culture — written from projects that shipped, not theory.
How I Design Scalable Laravel Architectures
The patterns I reach for when a Laravel codebase needs to survive years of growth: bounded contexts, thin controllers, and queues as a first-class citizen.
Building Fast E-commerce Frontends with Next.js
Commerce frontends live and die by perceived speed. How server components, smart caching, and disciplined hydration turn catalogs into conversion.
When to Use WordPress, Laravel, or Headless CMS
A decision framework from someone who ships all three: match the tool to the team that will run the platform, not to developer preference.
Practical AI Integrations with LangChain and Vector Databases
What actually matters when you connect an LLM to real business data: sync pipelines, retrieval quality, and permission-aware answers.
Clean Code Is Like Good Handwriting
Nobody compliments legible handwriting — they just read it without friction. The same quiet quality is what clean code is actually for.
DevOps Lessons from Real Production Systems
Hard-won lessons from years of keeping client platforms alive: boring deploys, honest monitoring, and why your rollback plan is the real pipeline.
Server Actions vs API Routes in Next.js: When to Use Which
Server Actions removed a lot of boilerplate, but they didn't make API routes obsolete. Here's the line I actually draw between them.
Scaling Laravel Queue Workers Without Losing Your Mind
Adding more workers is the easy part. Keeping them from stampeding your database is where most Laravel queue setups actually fail.
Migrating a Legacy Codebase to TypeScript Strict Mode
Flipping strict mode on a five-year-old codebase in one commit is how migrations die. Here's the incremental path that actually finishes.
RAG vs Fine-Tuning: Choosing the Right Tool for Your LLM Use Case
Clients often ask for fine-tuning when what they actually need is better retrieval. Here's how I tell the two apart before writing any code.
Docker Compose Setups That Actually Speed Up Local Development
A docker-compose.yml that takes four minutes to boot isn't a dev environment, it's a punishment. The fixes are almost always the same three things.
The OWASP Top 10, As I've Actually Seen Them Break Production
The OWASP list reads like theory until you've fixed each one in a real client codebase. Here's what they actually look like in the wild.
Postgres or MySQL in 2026: A Decision Framework, Not a Religion
Both databases are excellent. The real decision is about what your team already knows and what your workload actually looks like.
What I Actually Do When Mentoring Junior Developers
Good mentorship isn't answering questions faster than a search engine. It's teaching someone to ask better questions of the code itself.
Headless WordPress with Next.js: The Parts Nobody Warns You About
The demo is always the same: fetch posts via GraphQL, render them in React. The parts that actually take weeks are preview mode and revalidation.
Why Playwright Replaced Cypress on Every New Project I Start
Cypress got teams to actually write end-to-end tests. Playwright is what I reach for now that those teams need those tests to run fast and everywhere.
The Mental Model That Finally Made React Server Components Click
Forget 'server' and 'client' as a spectrum. The model that actually clicked was thinking in terms of what crosses the network boundary.
Three Patterns for Multi-Tenancy in Laravel, and When Each Breaks
Single database with a tenant column, separate databases, or separate schemas — each pattern is right for a specific scale, and wrong past it.
Prompt Engineering Practices That Survive Production, Not Just Demos
A prompt that works in a playground and a prompt that survives real user input, edge cases, and six months of drift are different disciplines entirely.
CI/CD for a Monorepo: Getting GitHub Actions to Only Build What Changed
A monorepo CI pipeline that rebuilds everything on every commit doesn't scale past a handful of packages. Path filtering and caching fix it.
Redis Caching Patterns That Don't Turn Into Invalidation Nightmares
Caching is easy to add and hard to invalidate correctly. The patterns that survive are the ones with an explicit owner and a documented TTL.
Chasing Core Web Vitals for Real Users, Not Lighthouse Scores
A perfect Lighthouse score on a fast office connection tells you almost nothing about the experience on a mid-range phone on real-world mobile data.
API Versioning Strategies for APIs Other Teams Depend On
The moment another team — or another company — depends on your API, versioning stops being optional. Here's how I've done it without breaking anyone.
How I Talk to Non-Technical Stakeholders About Technical Debt
'We need to refactor' loses every prioritization meeting. The conversation that wins is about the feature it's currently slowing down.
Making WooCommerce Fast at Catalogs Beyond 50,000 Products
WooCommerce's reputation for slowness at scale is mostly a reputation for unoptimized defaults. Here's what actually moves the needle.
JWTs vs Sessions: The Auth Debate That Refuses to Die
JWTs solved a real scaling problem and got oversold as a universal replacement for sessions. Most apps still don't need what JWTs actually offer.
Livewire or Inertia? Choosing a Laravel Frontend Without a SPA Framework
Both let you skip building a separate API. The right choice depends on how much of your frontend actually needs to feel like a real SPA.
Choosing a Vector Database: What the Benchmarks Don't Tell You
Recall-at-k benchmarks all look similar past a point. Operational cost, filtering, and hybrid search support are what actually differentiate them.
Infrastructure as Code for Small Teams: A Pragmatic Terraform Setup
Most Terraform guides assume a platform team of ten. Here's the scaled-down structure that works for a team of two maintaining real infrastructure.
The Database Indexing Mistakes I See in Almost Every Audit
Most slow-query problems aren't missing indexes — they're indexes that exist but don't match how the application actually queries.
Building a Design System on Tailwind Without It Becoming Spaghetti
Tailwind's flexibility is exactly what turns into inconsistency at scale, unless the design tokens are enforced somewhere other than developer memory.
Microservices: The Question Isn't Can You, It's Should You Yet
Almost every team that adopts microservices early is solving an organizational problem they don't have yet with an architecture cost they'll pay immediately.
Writing Incident Postmortems People Actually Read
A postmortem stuffed with jargon and blame gets skimmed once and filed away. The ones that prevent repeat incidents are structured completely differently.
GraphQL vs REST: What Changed My Mind After Real Client Projects
GraphQL's pitch is compelling on a whiteboard. What actually changed my mind about when to use it came from shipping both on real deadlines.
Testing Laravel Applications with Pest: A Practical Migration Guide
PHPUnit works fine. Pest's expressive syntax and lower ceremony made our test suite grow instead of stall — here's how the migration actually went.
Cutting LLM API Costs by 70% Without Hurting Answer Quality
Most LLM cost problems aren't about the model being expensive. They're about paying full price for calls that never needed the full model.
React Native or Flutter in 2026: What I Tell Clients Who Ask
Both are mature, capable frameworks now. The decision that actually matters is about the team you'll hire to maintain it, not a feature comparison.
Zero-Downtime Deployments for a Laravel Monolith
Zero downtime isn't a hosting feature you switch on. It's a set of deliberate decisions about migrations, sessions, and how traffic gets switched.
SQL Injection Still Happens in 2026 — Here's How
Every modern ORM protects against naive SQL injection by default. The real injection findings I still see are in the places ORMs don't cover.
Getting Next.js Image Optimization Right for a Global Audience
The `next/image` component does most of the work automatically. The remaining decisions still cost real seconds for users on slower connections.
Event-Driven Architecture in Laravel Without Overengineering It
Laravel's events and listeners are enough event-driven architecture for most apps. Reaching for a message broker before you need one adds cost, not value.
Building a Code Review Culture That Catches Bugs, Not Egos
The difference between a code review culture that improves a codebase and one that just creates friction is almost entirely about how feedback is phrased.
Hardening WordPress for Client Sites That Handle Real Traffic
WordPress's security reputation is mostly a plugin and configuration problem. A hardened, well-maintained install is genuinely solid.
Setting Up Observability with Prometheus and Grafana for a Laravel App
Logs tell you what happened. Metrics tell you it's happening right now. A Laravel app needs both, and Prometheus plus Grafana gets you the second half cheaply.
TypeScript Generics: The Patterns I Actually Use, Not the Ones in Tutorials
Most generics tutorials build a contrived stack or queue class. Here's where generics actually earn their keep in real application code.
Running Database Migrations on a Live System Without Downtime
The migration itself is rarely the risk. Locking a large table mid-traffic, or a schema that isn't backwards-compatible for a moment, is.
Building AI Agents with Tool Use: Lessons from Production
An agent that can call tools is powerful and genuinely unpredictable. The engineering that makes it safe in production isn't glamorous.
What Changed When I Moved from Freelancing to Leading an Engineering Team
Freelancing rewards individual output. Leading a team rewards making other people's output better — the skills barely overlap.
Rate Limiting APIs Without Punishing Your Best Customers
A flat rate limit treats your biggest customer the same as a scraper. The limiting strategies that actually work are more deliberate than that.
SSR, SSG, ISR: The Rendering Tradeoffs Next.js Makes You Choose
Next.js offers four rendering strategies for a reason — none of them is universally correct, and picking wrong shows up as either stale content or slow pages.
RabbitMQ Patterns for Reliable Background Processing
RabbitMQ's flexibility means there are several ways to build a queue, and only some of them survive a worker crashing mid-message.
Web Accessibility in Practice: What Client Projects Actually Need
Accessibility gets treated as an audit checklist at the end of a project. The teams that ship genuinely accessible sites build it in from the first component.
Modernizing a Legacy PHP Codebase Without a Rewrite
A full rewrite is rarely approved and rarely finishes. The modernization path that actually ships runs alongside the legacy code, not instead of it.
CDN and Edge Caching Strategy for a Multi-Region Audience
A CDN in front of your app is not the same as a caching strategy. The cache-control decisions still have to be made deliberately, per route.
Technical Interviews That Actually Predict Good Engineers
Whiteboard algorithm puzzles predict who studied algorithm puzzles. Here's the interview format that's actually correlated with strong hires on my teams.
From Docker Compose to Kubernetes: When the Jump Is Worth It
Kubernetes solves orchestration problems most teams don't have yet. The jump is worth it at a specific, identifiable point — not by default.