Cloud Scale

Ship the environment with the code. The packaging unit of modern compute.

Design for the small screen first. Became table stakes, not a differentiator.

One deployable with clear boundaries. The unfashionable default that keeps shipping while microservices argue about ownership.

Container orchestration that became the cloud's OS. Overkill for many; unavoidable for many others.

In-memory data processing that made Hadoop feel overnight. Still the batch/stream workhorse under many lakehouses.

Durable log as nervous system. Event-driven architecture with real operational teeth.

Fast structures in memory with persistence options. Cache, queue, session store — pick your footgun.

Components and unidirectional data. Won the front-end by being good enough and having a gravitational ecosystem.

Small language spec, fast compiles, great concurrency story. Cloud infra's favorite hammer.

Declarative infra with state files everyone learns to fear. The closest thing to versioned datacenters.

Apple's successor to Objective-C. The price of admission to serious iOS and macOS development.

Java without the boilerplate ceremony. Google's Android pick and Spring's polite nod kept it climbing.

The bundler that taught JavaScript developers what suffering means. Still under legacy apps; Vite owns greenfield.

YAML over SSH that sysadmins could actually read. The config-management winner by approachability.

Document DB that became a punchline, then a grown-up product. Survived by getting serious about transactions and ops.

Full-text search and log analytics at scale. Powerful, hungry, and everywhere in observability stacks.

Progressive framework with a friendlier learning curve. Steady share without the cult volume.

Compile away the framework. Less runtime theater, more shipped HTML — including this site.

Thin routing layer on Node that became the default API sketchpad. Middleware culture in a single file.

Binary RPC with contracts. Fast internal glue that should never face the public internet without a gateway.

BEAM reliability with modern syntax. Phoenix and LiveView keep the torch for pragmatic functional web.

Hermetic builds for monorepos that hurt until they save you. Google brainworm or serious reproducibility — pick one.

Real-time Elixir on the BEAM with HTML-over-the-wire before it was cool. Small but fiercely loyal community.

Wide-column store built for Netflix-scale write throughput. Resume-driven clusters optional.

Property graph database that finally made graph queries a product. Niche that pays when the graph is the domain.

Independent deployability as religion. Correct for some; ruinous cargo-cult for most.

$ 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.

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.

Hide SQL until N+1 queries own your night. Good ORMs survived; "never write SQL" didn't.

Plugin palace CI that defined pipeline culture — and Groovy nightmares. Still running somewhere in your org.

Convention-over-configuration SPA framework. LinkedIn and Discourse kept the faith; everyone else went React.

Mobile UI kit on Cordova then Capacitor. Still ships hybrid apps for teams that prioritize one codebase over polish.

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.

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.

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.

Datacenter kernel before Kubernetes won the orchestration war. Twitter survived on it; most did not need it.

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.

Two-way binding magic that became a migration tax. Angular 2+ was a rewrite; the 1.x apps lingered for years.

Full-stack JS with live data sync before anyone agreed on modules. Magic demo, fragile production.

C# for iOS and Android before Flutter and React Native won the cross-platform narrative.

Google's web components push before the platform was ready. Shadow DOM slides; React won the component war.

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.

Document store with replication and offline sync as the headline. MongoDB took the NoSQL spotlight.

Ruby DSL infrastructure as code with cookbooks and a community site. Ansible ate the simpler path.

Declarative config management with a heavy enterprise sales motion. Still haunts datacenters that virtualized early.

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.

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.

The first JavaScript task runner that made config files a lifestyle. Gulp and webpack ate its lunch.

Streaming build pipelines with code-over-config aesthetics. Briefly cool; webpack became the sun.

Front-end package manager before npm figured out flat dependency trees. jQuery plugins as a service.

Dynamo-inspired KV store from Basho. Bet on eventual consistency; lost to operational simplicity elsewhere.

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.