Published Nov 15, 2026

Headless, agents, multisite, microservices: don’t start when you can finish

By Kevin Champlin

The moment we learned “maybe later” was actually “never”

On a Fortune 500 apparel brand modernization, the plan was clean on paper: keep WordPress for authoring, go headless for storefront performance, then add AI “agents” to triage broken content and regenerate product descriptions. The kickoff ended with a diagram that looked like an architecture textbook.

Two weeks later we had: a higher error rate, slower core web vitals, and a chatbot that confidently hallucinated a discontinued SKU as “in stock.” The failure mode wasn’t that the tech was bad—it was that the rollout order was wrong and the blast radius was huge.

Concrete numbers: we went from ~92th percentile TTFB of 180–220ms on the legacy stack to ~650–900ms on the headless build because every search/filter interaction triggered extra round-trips and cache revalidation work. Support tickets for “inventory mismatch” climbed from single digits per week to 40+ in the first sprint. And the AI triage agent ate ~35% of our engineering time maintaining prompt/versioning/guardrails instead of fixing the actual taxonomy and product feed issues.

That’s when I stopped treating headless, agents, multisite, and microservices as “maturity steps” and started treating them as “risk multipliers.” Some things are only worth adding when the problems they solve are already real and contained.

My hard rule: don’t add distributed complexity to solve an unknown problem

Most teams get this wrong because they design for future capabilities instead of for the current bottleneck. In the apparel brand case, the real blockers were: content model drift, inconsistent product attributes, and cache invalidation rules that nobody fully owned. Headless and agents didn’t reduce those unknowns—they increased the number of systems with opinions.

So here’s my stop list: when NOT to use each approach. These aren’t philosophical takes. They’re based on failure modes I’ve seen in production across WordPress/WooCommerce modernization and our Laravel-based SaaS work (Vantage AI, Diamond AI, and the AI Showcase).

When NOT to use headless WordPress

Headless is worth it when you truly need it: multiple frontends, aggressive performance constraints, or you’re replacing WordPress presentation with something that can’t be done in theme land. But I’d avoid it when any of these are true:

  • Your bottleneck is content modeling, not rendering. If your product taxonomy, custom fields, and search logic are inconsistent, headless won’t fix it. It just changes where the inconsistency breaks.
  • You can’t control cache invalidation. In headless, stale caches and revalidation storms are common. If you don’t already have a cache ownership plan, don’t multiply it across CDN + API layer + frontend store.
  • You’re not ready for observability. You need distributed tracing across WP, the API layer, and the frontend. If you can’t answer “which hop added 400ms?” quickly, you’ll fight ghosts.
  • Your edit workflows rely on theme-driven behaviors. If your merch team expects “what they see in preview is what ships,” you’ll spend weeks rebuilding theme logic as components.

War story fix: We paused the headless storefront and shipped a “theme-first modernization” instead: cleaned product attribute mapping, tightened WooCommerce query patterns, and introduced a single caching strategy. We got Core Web Vitals back under control, and only then did we prototype headless for a subset of templates.

Result: we recovered ~0.7s on perceived load for key PDP interactions and cut “inventory mismatch” incidents by more than 80%—not because headless failed, but because we fixed the data correctness problem first.

When NOT to use AI agents (especially “autonomous” ones)

Agents are not just chatbots with tools; they’re systems that make decisions under uncertainty. I’m very cautious when:

  • The action surface has external consequences. Anything that changes inventory, customer comms, pricing, or production content should not be “agent-driven” without approvals.
  • You don’t have deterministic inputs. If your agent depends on scraped HTML, inconsistent product feeds, or dynamic CMS states, your agent will treat noise as signal.
  • You don’t have budgets and kill-switches. In production, “infinite loops” look like “helpful extra work.” We build guardrails like kill-switches and budget ceilings into our AI Showcase for a reason.
  • You’re using agents to compensate for missing engineering ownership. If the reason content breaks is missing validation and tests, an agent becomes a band-aid generator.

Concrete example from our playbook: In the AI Tax (PHP/MySQL layoff tracker), we never let the model act without checks. We treat the LLM as a classifier/extractor and keep write operations behind deterministic validation. That’s how you avoid “confidently wrong” updates that require manual rollback.

Tradeoff: You can absolutely automate support workflows with an agent, but keep it in “recommendation mode” until you can measure accuracy under real distribution shift. When the cost of being wrong is high, “fewer but safer” automations beat “more but riskier” ones.

When NOT to use WordPress multisite

Multisite is one of those features that teams love because it looks like consolidation. In practice, it’s often consolidation of pain. Avoid it when:

  • Different sites truly have different release cadences. If marketing teams need weekly changes and other sites need quarterly compliance updates, multisite becomes a coordination tax.
  • You’re expecting strong isolation. Multisite can share infrastructure while still giving you confusing cross-site interactions through plugins, themes, and shared hooks. Role-based access edge cases can become a time sink.
  • You don’t have a clear data boundary. If each site has different product catalogs, different permissions, and different compliance requirements, multisite can turn into a permissions labyrinth.
  • You need high customization per site. When 80% of settings diverge, multisite becomes a wrapper over “almost separate WordPress installs.” You’ll still rebuild most things.

Failure mode I’ve seen: A plugin update added a global filter that behaved differently depending on site context, causing only one tenant to display incorrect pricing labels. The debug time was hours, not because the bug was hard, but because “where did the context come from?” became the question.

When the sites behave differently enough, I’d rather do fewer shared pieces with clear boundaries (separate installs, or a controlled shared codebase) than “one network to rule them all.”

When NOT to use microservices

Microservices are the most expensive way to buy failure modes. I recommend against microservices when:

  • Your team can’t own cross-service reliability. If nobody is on point for distributed tracing, SLOs, retries, idempotency, and failure injection, microservices will turn outages into blame storms.
  • You don’t have stable domain boundaries. Microservices amplify churn. If your domain model is still moving (common in modernization projects), you’re splitting the churn across services.
  • Your traffic patterns don’t justify it. If you’re not actually solving a scaling hotspot, you’re paying operational overhead with no compensating benefit.
  • You’re still figuring out your data consistency strategy. Eventual consistency sounds good until your UI needs “this must be true now.”

War story fix: On a regulated beverage portfolio project, we nearly split checkout, catalog normalization, and recommendations into separate services. We found the real issue in profiling: a single database query pattern in the monolith was causing a cascade of slow requests under concurrency. We fixed the query, added proper indexing, and improved cache strategy. The “microservices” plan would’ve added network latency and complicated correctness without reducing the actual bottleneck.

We measured it: p95 request latency dropped ~40% after the DB/query fix, and the “system we almost built” stayed a monolith. That decision made our release process boring—in the best possible way.

What I recommend instead: pick the smallest architecture that makes the risk measurable

Here’s my senior-engineer heuristic:

  • Start with a monolith + clean boundaries. A Laravel monolith (or a WP+API boundary) with strong modules buys you iteration speed.
  • Move to headless only when you can validate performance and correctness with tracing. Treat headless as a product experiment, not a foundation swap.
  • Use agents for extraction/classification before you use them for actions. We do this across our applied-AI work: constrain inputs, validate outputs, then write.
  • Use multisite only when tenants share enough that the release process is truly shared. If it isn’t, separate installs win.
  • Use microservices only when you can name the scaling/ownership problem and instrument it. If you can’t set SLOs for each service, don’t create them.

The point isn’t “never do these things.” It’s “don’t do them first.” If you can’t explain why each addition reduces a known bottleneck and how you’ll measure risk, you’re not engineering—you’re decorating.

Monday-morning quote

Don’t add headless, agents, multisite, or microservices until you can name the production bottleneck, bound the blast radius, and measure reliability—otherwise you’re just multiplying failure modes.

At Champlin Enterprises, we treat architecture as a sequence of risk reductions: we modernize WordPress/WooCommerce with performance and data correctness first, then we introduce Laravel integrations and applied-AI with validation guardrails—only when the problem is real and instrumented, not hypothetical. View recent modernization and platform work.

Free Tool

See exactly what AI costs — across every provider.

MyTokenTracker is a free, multi-provider intelligence platform with live pricing across 100+ models. Compare Claude, GPT-4o, Gemini, and more side-by-side — built for developers evaluating models, teams tracking API spend, and founders building AI-native products who want to stay cost-aware before it becomes a line item worth explaining.