Costliest fads

Distributed consensus for problems that needed a database and an audit log.

$ Enterprises funded "innovation labs" to put loyalty points and supply-chain spreadsheets on ledgers. Most pilots ended as slide decks; the gas fees and audits did not.

Message bus in the middle of everything. SOA's plumbing invoice with vendor licensing.

$ Middleware vendors sold central buses that became single points of failure and political bottlenecks. Integration teams grew; end-to-end latency did too.

Reuse via shared services — in theory. In practice: central buses and political ownership fights.

$ ESBs, governance boards, and "service portfolios" burned seven-figure programs. Many orgs got distributed monoliths with worse latency and a permanent integration team.

Customize the ERP until upgrades are impossible. The enterprise tax that keeps consultants in villas.

$ ABAP extensions and bespoke modules that made every upgrade a multi-year program. Millions spent aligning ERP to process instead of process to ERP.

Independent deployability as religion. Correct for some; ruinous cargo-cult for most. Consolidation and monolith return are the 2020s epilogue.

$ Teams split 4-person products into 40 services, then hired SREs to babysit the mesh. Many later consolidated — after years of distributed tracing invoices and on-call trauma. See case studies on premature microservices and big-bang cutovers for named failure modes.

Sidecar proxies for every microservice. Netflix problems with startup headcount.

$ Istio sidecars on three-service startups burned SRE headcount on mTLS ceremonies nobody could debug. Many teams ripped mesh out before the observability dashboard paid rent.

Big-bang rewrite, now with a chatbot — then with agents. Same failure mode; prettier slides.

$ Exec decks promised autonomous migrations "by next quarter," then rebranded as "agentic modernization." Teams that skipped tests, ownership, and incremental strangler patterns bought expensive demos and fragile diffs.

Give the model a goal and a credit card. Viral in 2023; quietly shelved when the loop never stopped spending.

$ Open-ended agent loops burned API credits chasing goals nobody specified well enough to finish. Demo videos outpaced production deployments by orders of magnitude.

Replace the working system instead of strangling it. A perennial money pit with new branding each decade.

$ "We'll freeze features and rewrite in the hot language." Multi-year projects shipped late, incomplete, or not at all — while competitors iterated on the ugly system that made money.

Language-agnostic distributed objects. Complexity scaled faster than value for most shops.

$ Enterprises spent years on IDL, ORBs, and vendor lock-in for distributed objects that SOAP and REST later made look quaint — after the invoices cleared.

Command/query separation as default architecture. Right for high-scale event domains; absurd for to-do lists.

$ Teams split read and write models for CRUD apps that never needed separate projections. Double the schemas, double the bugs, double the on-call surface — for a blog admin.

Store every state change as an eternal log. Audit gold for some domains; operational nightmare as a default.

$ Immutable event logs for domains that needed UPDATE statements. Replay debugging sounded elegant until production needed GDPR deletes and schema migrations on millions of events.

MapReduce as lifestyle. The elephant in rooms that needed a spreadsheet.

$ Enterprises stood up Hadoop clusters for gigabytes of data that fit on one Postgres instance. Hadoop admins, ZooKeeper nightmares, and ETL rewrites burned millions before Spark and cloud warehouses retired the elephant.

LangGraph, CrewAI, AutoGPT cosplay — then vendor harnesses shipped the same loop as an API. Open-source swarms faded; leased orchestration stuck.

$ Autonomous agent swarms burned API budgets on coordination loops that a single prompt and a cron job would have handled. Debugging "which agent lied" became the new on-call sport.

Schema-optional databases sold as a lifestyle. Right tool for some jobs; default for none.

$ Startups ditched Postgres for document stores "because scale," then rebuilt relational integrity in application code — and paid twice when joins came back as a product requirement.

BaaS before Firebase owned the category. Open-sourced on the way out; trust never recovered.

$ Facebook shut down Parse with a year's notice, forcing thousands of mobile backends into emergency migrations or self-hosted forks.

Ship the chatbot, bolt on security later — OWASP's new category, same old afterthought.

$ Customer-facing chatbots shipped with tool access and "security in phase two." Indirect injection via docs and tickets became the new XSS.

Agile at enterprise scale with certifications and train metaphors. Process theater with a subscription model.

$ Certified release trains, PI planning offsites, and agile coaches billing seven figures to wrap waterfall in sticky notes. Velocity went up on slides; cycle time often did not.

Prod data into consumer chat because the approved tool is slow. GDPR with better autocomplete.

$ Employees routed tickets, logs, and customer PII through consumer chat before InfoSec finished procurement. Compliance scramble followed the demos.

Enterprise web services with ceremony. Interoperability theater with XML envelopes.

$ Banks and governments sunk fortunes into WS-Security, WSDL toolchains, and vendor stacks — then quietly rebuilt on REST/JSON while still paying maintenance on the old bus.

Accept AI output on feel, skip the diff, hope tests exist. Fast demos; CVEs and nobody owns the middleware.

$ Ship-to-prod without reading the diff became a flex until incidents revealed nobody knew which prompt wrote the auth middleware. Review debt arrived in one weekend demo.

Coverage theater with a chat box. Tests that mirror the bug and never catch it.

$ LLMs wrote tests that boosted coverage and asserted nothing. Green CI, false confidence — eval theater's cousin in the test suite.

HTML in a native WebView with camera plugins. The first cross-platform mobile bet before React Native ate lunch.

$ Teams shipped WebView shells as "native apps," then paid twice for performance fixes, plugin rot, and App Store rejections when users noticed the jank.

Slap an LLM on the homepage and call it AI-native — "we have an app now," 2010 edition.

$ Homepage chat boxes billed as AI-native platforms while the roadmap stayed FAQ search with a spinner. Acquisition decks outpaced retention.

Decentralize data ownership like microservices for warehouses. Real org problem; often a logo refresh for the same broken pipelines.

$ Consultancies sold domain ownership and federated governance while teams still could not agree on a customer ID. Slideware outpaced catalog tooling by years.

If it is text, vectorize it. Semantic search cosplay for problems that needed a better filter.

$ Embedding pipelines for tickets, PDFs, Slack, and the cafeteria menu — then nobody measured retrieval quality. Vector bills and reindex jobs became the product.

LLM evals as slideware — metrics that look scientific and never gate a deploy. The foil to real eval pipelines in CI.

$ Dashboards of vibe-check scores that never blocked a release. Green charts for leadership; prod still hallucinated.

When in doubt, fine-tune. Often the expensive answer to a retrieval or eval problem — mostly shelved as a default by 2025.

$ Fine-tune jobs and GPU bills for problems that prompt + retrieval would have solved. Model zoos became the new snowflake servers.

git push deploy and twelve-factor bliss. The PaaS that taught a generation what deploy should feel like — then priced them out.

$ Free-tier sunsetting and Salesforce neglect sent hobbyists and startups shopping mid-project. Dyno pricing that made sense at demo scale became a line item at traction.

EJB-heavy stacks taught a generation that XML config was architecture. Spring and lighter runtimes absorbed the survivors.

Chains, tools, memory, and agents as a framework — LangChain-class glue sold as architecture. Fatigue was real; the repos became MCP clients, not tombstones.

$ Teams adopted chain/agent frameworks before they had a single reliable tool call. Abstraction layers multiplied while prompt quality stayed flat.

Million-token windows as a substitute for retrieval design. Stuffing PDFs until the model shrugs.

$ "Just put it in the window" replaced chunking, RAG, and information architecture until token bills and lost-in-the-middle hallucinations arrived.

Retrieval-augmented generation as the answer to every knowledge problem — then "just stuff the window" as the counter-fad. Often right; often Postgres with pgvector would suffice.

$ Teams stood up vector pipelines, chunking strategies, and rerankers before asking if fine-tuning or a SQL query would answer the question. Retrieval infra became the product.

o1-class deliberation for tickets that needed a filter. Resume-driven inference.

$ Thinking tokens burned on problems a SQL query and a unit test would settle. Latency and invoices grew; correctness did not.

.NET in the browser via plugin. Netflix used it; the web moved on anyway.

$ Enterprises built internal dashboards and streaming pilots on Silverlight just as HTML5 and iOS said no to plugins. Migration projects burned budgets Flash already warned them about.

Client-side apps as the only architecture. Great for apps; absurd for brochures.

$ Marketing sites and docs portals shipped multi-megabyte JS bundles for content that wanted HTML. SEO and performance teams spent years unwinding "modern" defaults.

The Codex/Claude loop as a product SKU — durable sessions, compaction, subagents, and a sandbox you do not own.

$ Teams replaced a weekend of LangGraph glue with a managed session API, then discovered residency, recovery, and kill switches all live on the vendor side of the harness.