Best of Monolith — 2025

1. 1
   Article

   Docker·25w

   You Want Microservices—But Do You Need Them?

   Microservices have become the default architectural choice despite their significant complexity costs. Amazon Prime Video achieved 90% cost reduction by reverting to a monolith, while companies like Twilio Segment and Shopify found success with simpler architectures. Industry leaders including GitHub's former CTO and GraphQL's co-creator warn that most organizations lack the scale to justify microservices overhead. The operational costs, developer productivity drain, testing complexity, and data consistency challenges often outweigh benefits. Modular monoliths and service-oriented architectures offer comparable scalability without distributed system complexity. Docker provides deployment consistency across any architecture, not just microservices. The key question: does your actual scale and team structure justify the microservices premium, or are you choosing complexity over business needs?

   149

   11
2. 2
   Article

   Foojay.io·42w

   Monolith vs Microservices in 2025

   The software architecture landscape in 2025 shows a shift from microservices hype toward balanced, context-driven decisions. Developer experience and simplicity are driving many teams back to monoliths or modular monoliths, while Infrastructure as Code tools like Terraform make architecture changes more manageable. Enterprises are embracing the stability and traceability of monolithic approaches, prioritizing sustainability and clarity over theoretical scalability. The debate has evolved from choosing sides to making informed decisions based on team needs, organizational context, and long-term maintainability.

   107

   5
3. 3
   Article

   InfluxData·48w

   Microservices to Monolith, Rebuilding Our Backend in Rust

   InfluxData's platform team migrated their core account and resource management APIs from Go microservices to a Rust monolith to reduce complexity and improve maintainability. They used a strangler fig migration pattern to migrate endpoints one by one without downtime, implementing hexagonal architecture with domain-driven design. The team of five completed the project in three months, achieving safer software through Rust's type system and faster development cycles.

   90

   4
4. 4
   Article

   Hacker News·32w

   Why is everything so scalable?

   A critical examination of the trend toward over-engineering for scale in startups. The author argues that most companies prematurely adopt complex, distributed architectures (microservices, cloud infrastructure, orchestrators) designed for FAANG-scale problems they don't have. Instead, they advocate for starting with a well-structured monolith using modular design with strict interface boundaries, static typing, and enforced separation of concerns. This approach provides clean architecture, atomic deployments, better type safety, and significantly lower costs while deferring the complexity of distributed systems until actually needed.

   47

   4
5. 5
   Article

   Architecture Weekly·1y

   Monolith-First - are you sure?

   The modular monolith architecture, though often advocated for its simplicity and ability to defer distributed system complexities, comes with inherent challenges. Boundaries between modules can erode, leading to tightly coupled systems that are hard to maintain and scale. Additionally, deployment, resource management, and tooling maturity can be significant hurdles. To avoid creating a ‘big ball of mud,’ one should consider modular-first principles and plan thoroughly for data isolation, module boundaries, and consistent DevOps processes.

   32

   5
6. 6
   Article

   Hacker News·28w

   Modular Monolith and Microservices: Modularity is what truly matters

   Modularity is the fundamental principle in software architecture, independent of whether you choose a monolith or microservices. The article explores five implementation strategies ranging from simple modular monoliths (modules as folders) to full microservices, emphasizing that good module separation based on domain understanding should drive architectural decisions, not the other way around. Key insight: start simple with a modular monolith and only increase complexity when justified by specific needs like resource optimization or team scaling. The author advocates for constrained microservices (microliths) that prohibit synchronous inter-service calls during request handling, reducing distributed system complexity while maintaining deployment independence.

   28

   1
7. 7
   Article

   Hacker News·23w

   Goodbye Microservices

   Twilio Segment migrated from 140+ microservices back to a monolithic architecture after microservices created unsustainable operational overhead. The team consolidated separate repos and queues into a single service with a unified test suite using Traffic Recorder. This transition dramatically improved developer productivity (46% more library improvements), reduced deployment complexity from 140+ services to one, and simplified scaling. While accepting trade-offs like reduced fault isolation and less effective in-memory caching, the monolith proved more suitable for their server-side destinations pipeline.

   19

   4