The End of the Monolith

Software architecture oscillates. We centralized into monoliths because hardware was expensive and coordination was cheap. We shattered them into microservices when scaling teams mattered more than scaling machines. Now the pendulum swings again — toward functions pinned to the edge, close to users, small enough to reason about alone.

This is not regression. Each swing raises the floor. The edge function inherits the isolation of microservices with none of the network choreography, because the deployment unit is small enough that one person can hold all of it in their head.

Users do not perceive your architecture diagram; they perceive milliseconds. A request that crosses three oceans and four queues cannot compete with one answered forty kilometers away. Physics is the only non-negotiable dependency in your stack.

Edge-first design treats response time as a product requirement, not an optimization target. Data gravity follows compute: keep the hot path local, replicate state aggressively, and accept eventual consistency where users cannot feel it.

Distributed systems fail differently. A monolith fails loudly — the process dies, the pager fires. An edge fleet fails partially, per-region, per-function, sometimes silently. Observability stops being a nice-to-have the moment your backend is geography.

The mitigation is the same discipline that powers solo engineering: typed contracts at every boundary, deterministic builds, and deploys that roll forward automatically. Small units, strong guarantees, fast feedback.

None of this requires believing the edge is superior in the abstract. It only requires noticing where the economics point: bandwidth keeps getting cheaper, regions keep getting closer, and deployment units keep getting smaller. The monolith was a phase, not a destination.