# modular-monolith

Modular monolith is a software architecture in which one deployable application is divided into independent modules with clear boundaries and minimal dependencies.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Top 13 Microservices Interview Questions Answered

DevFeed: [Top 13 Microservices Interview Questions Answered](<https://devfeed.tech/articles/top-13-microservices-interview-questions-answered-146768.md>)

Original publisher: [Read original article](<https://newsletter.systemdesign.one/p/microservices-interview-questions>)

Author: Neo Kim

Published: 2026-11-20T12:02:22Z

Content type: article

Language: en

Sources: [System Design Newsletter](<https://devfeed.tech/sources/system-design-newsletter.md>)

Topics: [Microservices](<https://devfeed.tech/topics/microservices.md>), [Cloud Architecture](<https://devfeed.tech/topics/cloud-architecture.md>), [observability](<https://devfeed.tech/topics/observability.md>), [service-mesh](<https://devfeed.tech/topics/service-mesh.md>), [modular-monolith](<https://devfeed.tech/topics/modular-monolith.md>), [monolithic-architecture](<https://devfeed.tech/topics/monolithic-architecture.md>), [Publish-subscribe pattern](<https://devfeed.tech/topics/pubsub.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [interview](<https://devfeed.tech/tags/interview.md>), [interview-questions](<https://devfeed.tech/tags/interview-questions.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [questions](<https://devfeed.tech/tags/questions.md>), [top](<https://devfeed.tech/tags/top.md>)

### AI overview

The article presents 13 microservices interview questions and stresses weighing operational costs against benefits. Microservices enable independent releases and scaling, but introduce network failures, distributed data, and tooling needs; for a small team or new product, it recommends starting with a modular monolith and extracting services when concrete pressures emerge. It explains boundaries based on business capabilities and bounded contexts, service-owned data with APIs or event-fed copies, and sagas with compensating actions for workflows spanning services. Other guidance distinguishes API gateways from load balancers and service meshes, client-side from server-side discovery, and SOA from microservices. It also covers circuit breakers, distributed tracing, shared rate-limit counters across gateway instances, and REST conventions such as idempotency keys for retried order requests.

### Source excerpt

#205: Ace Software Engineering Job Interviews

## We Promised Three Months. It Took Nine.

DevFeed: [We Promised Three Months. It Took Nine.](<https://devfeed.tech/articles/we-promised-three-months-it-took-nine-131444.md>)

Original publisher: [Read original article](<https://newsletter.techworld-with-milan.com/p/we-promised-three-months-it-took>)

Author: Dr Milan Milanović

Published: 2026-11-12T16:02:49Z

Content type: article

Language: en

Sources: [Tech World With Milan Newsletter](<https://devfeed.tech/sources/tech-world-with-milan-newsletter.md>)

Topics: [engineering-leadership](<https://devfeed.tech/topics/engineering-leadership.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [bus factor](<https://devfeed.tech/topics/bus-factor.md>), [software development triangle](<https://devfeed.tech/topics/software-development-triangle.md>), [engineering-culture](<https://devfeed.tech/topics/engineering-culture.md>), [Documentation](<https://devfeed.tech/topics/documentation.md>), [modular-monolith](<https://devfeed.tech/topics/modular-monolith.md>), [Developer experience](<https://devfeed.tech/topics/developer-experience.md>), [Tech Debt](<https://devfeed.tech/topics/tech-debt.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [api](<https://devfeed.tech/tags/api.md>), [bus-factor](<https://devfeed.tech/tags/bus-factor.md>), [conway-s-law](<https://devfeed.tech/tags/conway-s-law.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [laws](<https://devfeed.tech/tags/laws.md>), [software](<https://devfeed.tech/tags/software.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>)

### AI overview

The billing-system rewrite took nine months despite a three-month estimate, illustrating how software laws can point in different directions because they apply under different conditions. The article recommends checking each law's assumptions, measuring outcomes with counter-metrics to discourage gaming, and diagnosing team problems by listing relevant forces, selecting three to five applicable laws, then addressing the strongest force first. Its examples include coordination costs from adding people, token boards rewarding usage rather than quality, and AI-generated services creating contract, comprehension, and integration problems. Practical responses described include agreeing on API contracts before code is written, documenting core modules, starting with a working modular system and extracting services as needed, preserving compatibility with users' observed dependencies, and budgeting time for integration, testing, documentation, handover, and deployment. In the rewrite, the author says the unrealistic deadline was the strongest force; reducing the initial launch scope to one country was the proposed correction.

### Source excerpt

What to do when software engineering laws point in opposite directions

## SymfonyCon Warsaw 2026: Headless vs Monolith: The Final Battle

DevFeed: [SymfonyCon Warsaw 2026: Headless vs Monolith: The Final Battle](<https://devfeed.tech/articles/symfonycon-warsaw-2026-headless-vs-monolith-the-final-battle-108365.md>)

Original publisher: [Read original article](<https://symfony.com/blog/symfonycon-warsaw-2026-headless-vs-monolith-the-final-battle>)

Author: Mélyne FREUZE

Published: 2026-10-30T13:30:00Z

Content type: news

Language: en

Sources: [Symfony](<https://devfeed.tech/sources/symfony-blog.md>)

Topics: [Symfony](<https://devfeed.tech/topics/symfony.md>), [modular-monolith](<https://devfeed.tech/topics/modular-monolith.md>), [Full Stack Development](<https://devfeed.tech/topics/full-stack-development.md>), [it modernization](<https://devfeed.tech/topics/it-modernization.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [3](<https://devfeed.tech/tags/3.md>), [about](<https://devfeed.tech/tags/about.md>), [all](<https://devfeed.tech/tags/all.md>), [announcement](<https://devfeed.tech/tags/announcement.md>), [backend](<https://devfeed.tech/tags/backend.md>), [community](<https://devfeed.tech/tags/community.md>), [headless](<https://devfeed.tech/tags/headless.md>), [international](<https://devfeed.tech/tags/international.md>), [let-s](<https://devfeed.tech/tags/let-s.md>), [monolith](<https://devfeed.tech/tags/monolith.md>), [people](<https://devfeed.tech/tags/people.md>), [php](<https://devfeed.tech/tags/php.md>), [poland](<https://devfeed.tech/tags/poland.md>), [speaker](<https://devfeed.tech/tags/speaker.md>), [symfony](<https://devfeed.tech/tags/symfony.md>), [talk](<https://devfeed.tech/tags/talk.md>), [up](<https://devfeed.tech/tags/up.md>), [vs](<https://devfeed.tech/tags/vs.md>), [warsaw](<https://devfeed.tech/tags/warsaw.md>)

### AI overview

The talk argues Symfony teams do not have to choose only between a server-rendered monolith and a fully headless application. It will compare them in an e-commerce context across SEO, performance, responsiveness, frontend flexibility, team workflow, deployment complexity, multiple-repository maintenance, and long-term cost, without declaring one universal winner. The proposed middle ground uses Symfony UX, Live Components, Twig Components, and React or Vue components within Twig to add interactivity where useful while retaining a traditional Symfony application's productivity and SEO advantages. The speaker says he will share lessons from implementing this approach at Sylius and offer a framework for deciding when to use a monolith, headless, or hybrid architecture.

### Source excerpt

Let's meet up in Poland! SymfonyCon Warsaw 2026 brings the international PHP and Symfony community together on November 26-27. Come for the 3 talk tracks, stay for the people. 🎤 Speaker announcement Mark your calendars for Gracjan Józefczyk, Backend...

## The Great Monolith Renaissance: Why Startups Are Fleeing Microservices

DevFeed: [The Great Monolith Renaissance: Why Startups Are Fleeing Microservices](<https://devfeed.tech/articles/the-great-monolith-renaissance-why-startups-are-fleeing-microservices-105535.md>)

Original publisher: [Read original article](<https://hackernoon.com/the-great-monolith-renaissance-why-startups-are-fleeing-microservices?source=rss>)

Author: Dua Amjad

Published: 2026-10-28T20:34:15Z

Content type: opinion

Language: en

Sources: [HackerNoon](<https://devfeed.tech/sources/hackernoon.md>)

Topics: [modular-monolith](<https://devfeed.tech/topics/modular-monolith.md>), [Microservices](<https://devfeed.tech/topics/microservices.md>), [observability](<https://devfeed.tech/topics/observability.md>), [Publish-subscribe pattern](<https://devfeed.tech/topics/pubsub.md>)

Tags: [amazon](<https://devfeed.tech/tags/amazon.md>), [api](<https://devfeed.tech/tags/api.md>), [apis](<https://devfeed.tech/tags/apis.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [backend](<https://devfeed.tech/tags/backend.md>), [billing](<https://devfeed.tech/tags/billing.md>), [bus](<https://devfeed.tech/tags/bus.md>), [cadence](<https://devfeed.tech/tags/cadence.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [clusters](<https://devfeed.tech/tags/clusters.md>), [code](<https://devfeed.tech/tags/code.md>), [communication](<https://devfeed.tech/tags/communication.md>), [compensating-transactions](<https://devfeed.tech/tags/compensating-transactions.md>), [development](<https://devfeed.tech/tags/development.md>), [devops](<https://devfeed.tech/tags/devops.md>), [great-monolith-renaissance](<https://devfeed.tech/tags/great-monolith-renaissance.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [modular-monolith](<https://devfeed.tech/tags/modular-monolith.md>), [monolith](<https://devfeed.tech/tags/monolith.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [scaling](<https://devfeed.tech/tags/scaling.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [startup](<https://devfeed.tech/tags/startup.md>), [startups](<https://devfeed.tech/tags/startups.md>), [tech-trends](<https://devfeed.tech/tags/tech-trends.md>)

### AI overview

The excerpt argues that small startup teams can lose product development time to microservices overhead, including cross-service coordination, network failure handling, distributed data consistency, and extra deployment and observability systems. It presents a modular monolith as one codebase and deployment with a shared database divided into modules, while acknowledging that keeping it maintainable is difficult. Suggested boundaries include separate database schemas and no cross-schema joins, an in-memory event bus for module communication, and public facades for accessing other modules. The decision matrix favors a monolith for teams of 1-20 building products with shifting requirements and a shared deployment cadence; it favors microservices for teams of 50+ with clear domain boundaries, differing deployment needs, or high DevOps headcount. These are the excerpt's recommendations and criteria.

### Source excerpt

Discover why tech startups are abandoning complex microservices to embrace the "Modular Monolith."Learn how reducing DevOps overhead can boost your development.

## Monolith vs Microservices vs Modular Monolith

DevFeed: [Monolith vs Microservices vs Modular Monolith](<https://devfeed.tech/articles/monolith-vs-microservices-vs-modular-monolith-102601.md>)

Original publisher: [Read original article](<https://blog.levelupcoding.com/p/monolith-vs-microservices-vs-modular>)

Author: Nikki Siapno

Published: 2026-10-27T14:22:01Z

Content type: article

Language: en

Sources: [Level Up Coding System Design Newsletter](<https://devfeed.tech/sources/level-up-coding-system-design-newsletter.md>)

Topics: [modular-monolith](<https://devfeed.tech/topics/modular-monolith.md>), [Microservices](<https://devfeed.tech/topics/microservices.md>), [Ktor](<https://devfeed.tech/topics/ktor.md>), [decoupling](<https://devfeed.tech/topics/decoupling.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>)

Tags: [microservices](<https://devfeed.tech/tags/microservices.md>), [modular-monolith](<https://devfeed.tech/tags/modular-monolith.md>), [monolith](<https://devfeed.tech/tags/monolith.md>)

### AI overview

Architecture choice depends on which parts of a system truly need to evolve independently. A monolith deploys as one unit, but can still have well-structured internal modules; a modular monolith enforces module ownership and interfaces while retaining in-process calls, one deployment, and local database transactions. Microservices move selected boundaries across the network, enabling independent deployment, scaling, ownership, technology choices, and fault isolation, at the cost of network failures, distributed tracing, operational overhead, and harder data consistency. Workflows that cross service databases may require sagas, retries, idempotency, eventual consistency, and compensating actions. Splitting services that still change or deploy together can create a distributed monolith, retaining coordination costs while adding distributed-system complexity. The article recommends choosing boundaries based on actual needs and evolving selectively: strengthen code boundaries first, and extract services where independent runtime behavior is valuable.

### Source excerpt

Microservices promise independence. But what do you give up to get it?

## DTO -\> Domain -\> UI Model: When Is the Mapping Worth It?

DevFeed: [DTO -\> Domain -\> UI Model: When Is the Mapping Worth It?](<https://devfeed.tech/articles/dto-domain-ui-model-when-is-the-mapping-worth-it-100952.md>)

Original publisher: [Read original article](<https://proandroiddev.com/dto-domain-ui-model-mapping-clean-architecture-2603f0010fcf?source=rss----c72404660798---4>)

Author: Ravi Rawal

Published: 2026-10-26T13:38:18Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [modular-monolith](<https://devfeed.tech/topics/modular-monolith.md>), [adapter pattern](<https://devfeed.tech/topics/adapter-pattern.md>), [business logic](<https://devfeed.tech/topics/business-logic.md>), [REST API](<https://devfeed.tech/topics/rest-api.md>), [MVVM](<https://devfeed.tech/topics/mvvm.md>), [Boilerplate](<https://devfeed.tech/topics/boilerplate.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [clean-architecture](<https://devfeed.tech/tags/clean-architecture.md>), [coupling](<https://devfeed.tech/tags/coupling.md>), [domain](<https://devfeed.tech/tags/domain.md>), [external](<https://devfeed.tech/tags/external.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [maintenance](<https://devfeed.tech/tags/maintenance.md>), [mapping](<https://devfeed.tech/tags/mapping.md>), [model](<https://devfeed.tech/tags/model.md>), [models](<https://devfeed.tech/tags/models.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [ui](<https://devfeed.tech/tags/ui.md>)

### AI overview

DTO -> Domain -> UI mappings are useful when they protect distinct responsibilities, but three models are not required by default. The article's product example separates an API-shaped DTO from a domain Product that interprets fields such as price, seller type, and status, then from a ProductCardUiModel that adds formatted price, localized labels, and favorite state. Mapping can validate or reject incomplete records, represent unknown values, and keep backend changes from spreading into business logic or presentation. A ViewModel can combine product and favorite data into card models and expose screen loading, content, or error state separately; Composables render that state. Keep a boundary when the next layer has different needs, rules, or likely reasons to change. For a small feature with a stable API, simple UI, and no meaningful domain behavior, fewer models may avoid duplicated declarations and mapping omissions. Android guidance cited in the article allows separate models for complex apps and treats the domain layer as optional. Use simple explicit mappers where sufficient; extract dedicated ones when rules, reuse, or independent testing justify them.

### Source excerpt

Three models, two mapping steps, and one simple question: are we protecting architectural boundaries or just creating more code to maintain? Open a mobile application built with Clean Architecture, and you will probably find some variation of this flow: ProductDto -> Product -> ProductUiModel The API response becomes a DTO. The DTO becomes a domain model. The domain model becomes a UI model. Each transformation has its own mapper, and each model lives in its own package or module. It looks clean. It follows familiar architectural conventions. It can also produce a surprising amount of code for displaying a product on a screen. And that raises a question worth discussing: does every layer need its own model, or have we turned a useful architectural technique into a rule that we follow without questioning? I have seen both sides of this design make sense. Sharing a network DTO throughout an application can create coupling that becomes expensive later. Introducing multiple models that contain the same properties, however, can create maintenance work without delivering much protection. The interesting part is knowing the difference. Let's follow one feature -- a product listing -- from the API response to the screen and examine what each model should contribute, where the transformations belong, and when we can reasonably skip them. Start with the API contract Imagine a marketplace application that fetches a list of products from a backend. The response for each listing looks something like this: https://medium.com/media/02059b91befe4e6cc4715d4de56bc69b/href The networking layer needs a model capable of representing this response. In Kotlin, it might look like this: https://medium.com/media/7cea74b0c4f9a5ff5de917c0b67df314/href The nullable properties are intentional. They acknowledge that the response may contain missing values, even when the backend's ideal contract says otherwise. The DTO represents an external contract. Its field names, serialization annotations, and da

## A Consolidated Deployment Edition of a Microservice Core-Banking Platform: Composing Services by Reference into Three Hosts

DevFeed: [A Consolidated Deployment Edition of a Microservice Core-Banking Platform: Composing Services by Reference into Three Hosts](<https://devfeed.tech/articles/a-consolidated-deployment-edition-of-a-microservice-core-banking-platform-composing-services-by-reference-into-three-hosts-96636.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.30212>)

Author: Tomisin Fagbola

Published: 2026-10-23T04:00:00Z

Content type: comparison

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [modular-monolith](<https://devfeed.tech/topics/modular-monolith.md>), [Deployment Strategies](<https://devfeed.tech/topics/deployment-strategies.md>), [health check](<https://devfeed.tech/topics/health-check.md>), [.NET](<https://devfeed.tech/topics/net.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [aws](<https://devfeed.tech/tags/aws.md>), [banking](<https://devfeed.tech/tags/banking.md>), [composition](<https://devfeed.tech/tags/composition.md>), [compute](<https://devfeed.tech/tags/compute.md>), [core-banking](<https://devfeed.tech/tags/core-banking.md>), [costs](<https://devfeed.tech/tags/costs.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [emulation](<https://devfeed.tech/tags/emulation.md>), [memory](<https://devfeed.tech/tags/memory.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [net](<https://devfeed.tech/tags/net.md>), [throughput](<https://devfeed.tech/tags/throughput.md>)

### AI overview

The paper compares a nine-task AWS ECS Fargate edition of a multi-tenant .NET core-banking platform with an alternative that composes five API services into one host, alongside consumer and background hosts. Service code stays in its original repositories, and both editions build from the same commits. In an AWS-topology emulation, the composed edition exposed all 844 declared operations; both editions matched outcomes and ledgers across 47 financial workloads. Read probes matched on 230 of 231 endpoint results, with the exception associated with the emulated load balancer. The composed edition achieved 2.3 times the read throughput, used less than half the memory, and had estimated service-task compute costs 11-24% lower at list prices. Those estimates exclude shared infrastructure and other operating costs. Consolidation widens the failure domain: one API-host crash takes all five modules offline. Checks and behavioural tests detected 15 of 16 injected faults. Results are limited to one platform in emulation, not production AWS measurements.

### Source excerpt

arXiv:2610.30212v1 Announce Type: new Abstract: Microservices give teams independent deployment and scaling, but each deployed service also reserves compute and adds operational work. This paper examines a second deployment edition of a multi-tenant .NET core-banking platform. The existing edition runs as nine AWS ECS Fargate tasks; the alternative composes the five API services by project reference into one API host, alongside a consumer host and a background host. The service code remains in its original repositories, and both editions continue to be built from the same commits. We describe the composition mechanism, module manifest, start-up checks, request handling and configuration precedence, then compare the editions in an emulation of the AWS deployment. The composed edition exposes all 844 declared operations. Across 47 financial workload cases, both editions produced the same observed outcomes and matching ledgers. In read probes across five principal types, 230 of 231 endpoint results matched; the remaining difference was associated with the emulated load balancer. Eleven cross-tenant and write-authorisation cases also produced the expected outcomes in both editions. In the emulation, the composed edition delivered 2.3 times the read throughput and used less than half the memory. Estimated service-task compute at list prices was 11-24% lower, excluding the shared gateway, load balancer, data stores and other operating costs. The consolidation also enlarges the failure domain: one API-host crash takes all five modules offline. Of 16 injected faults, the edition's checks detected 10, behavioural tests detected five additional faults, and one fault escaped both. These findings concern one platform and an emulated deployment that mirrors its topology, task sizes and configuration; they are not production-AWS measurements.

## Modular Monolith in .NET: Why Many Teams Skip Microservices

DevFeed: [Modular Monolith in .NET: Why Many Teams Skip Microservices](<https://devfeed.tech/articles/modular-monolith-in-net-why-many-teams-skip-microservices-85890.md>)

Original publisher: [Read original article](<https://blog.devops.dev/modular-monolith-in-net-why-many-teams-skip-microservices-b70d52278ccc?source=rss----33f8b2d9a328---4>)

Author: Bharat Chandera

Published: 2026-10-13T10:52:09Z

Content type: opinion

Language: en

Sources: [DevOps.dev](<https://devfeed.tech/sources/devops-dev.md>)

Topics: [modular-monolith](<https://devfeed.tech/topics/modular-monolith.md>), [Microservices](<https://devfeed.tech/topics/microservices.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [costs](<https://devfeed.tech/tags/costs.md>), [coupling](<https://devfeed.tech/tags/coupling.md>), [csharp](<https://devfeed.tech/tags/csharp.md>), [debug](<https://devfeed.tech/tags/debug.md>), [distributed-data](<https://devfeed.tech/tags/distributed-data.md>), [distributed-transactions](<https://devfeed.tech/tags/distributed-transactions.md>), [dotnet](<https://devfeed.tech/tags/dotnet.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [modular-monolith](<https://devfeed.tech/tags/modular-monolith.md>), [monolith](<https://devfeed.tech/tags/monolith.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [pipelines](<https://devfeed.tech/tags/pipelines.md>), [services](<https://devfeed.tech/tags/services.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [software-development](<https://devfeed.tech/tags/software-development.md>)

### AI overview

The excerpt argues that many teams adopt microservices to address code coupling rather than scaling needs, and that a modular monolith can improve boundaries within one process. It says microservices impose costs such as distributed data without joins or a single transaction, per-service pipelines and operations, slower local development, and failure modes including timeouts and partial failures. For teams of 5 to 30 developers, the excerpt says this overhead may outweigh the coupling cost; it does not describe how to implement a modular monolith.

### Source excerpt

You probably don't have a scaling problem. You have a boundaries problem, and there's a cheaper way to fix it. Continue reading on DevOps.dev "

## This Week in Spring - October 13th, 2026

DevFeed: [This Week in Spring - October 13th, 2026](<https://devfeed.tech/articles/this-week-in-spring-october-13th-2026-86662.md>)

Original publisher: [Read original article](<https://spring.io/blog/2026/10/13/this-week-in-spring-october-13th-2026>)

Author: joshlong

Published: 2026-10-13T00:00:00Z

Content type: article

Language: en

Sources: [Spring](<https://devfeed.tech/sources/spring.md>)

Topics: [modular-monolith](<https://devfeed.tech/topics/modular-monolith.md>), [Spring Boot](<https://devfeed.tech/topics/spring-boot.md>), [Spring AI](<https://devfeed.tech/topics/spring-ai.md>), [IntelliJ IDEA](<https://devfeed.tech/topics/intellij-idea.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [Learning](<https://devfeed.tech/topics/learning.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [application](<https://devfeed.tech/tags/application.md>), [approach](<https://devfeed.tech/tags/approach.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [batch](<https://devfeed.tech/tags/batch.md>), [boot](<https://devfeed.tech/tags/boot.md>), [cli](<https://devfeed.tech/tags/cli.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [event-driven](<https://devfeed.tech/tags/event-driven.md>), [intellij](<https://devfeed.tech/tags/intellij.md>), [intellij-idea](<https://devfeed.tech/tags/intellij-idea.md>), [java](<https://devfeed.tech/tags/java.md>), [jenkins](<https://devfeed.tech/tags/jenkins.md>), [jobrunr](<https://devfeed.tech/tags/jobrunr.md>), [layers](<https://devfeed.tech/tags/layers.md>), [learning](<https://devfeed.tech/tags/learning.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [patterns](<https://devfeed.tech/tags/patterns.md>), [podcast](<https://devfeed.tech/tags/podcast.md>), [reactive](<https://devfeed.tech/tags/reactive.md>), [serverless](<https://devfeed.tech/tags/serverless.md>), [spring](<https://devfeed.tech/tags/spring.md>), [spring-ai](<https://devfeed.tech/tags/spring-ai.md>), [spring-boot](<https://devfeed.tech/tags/spring-boot.md>), [tool-calling](<https://devfeed.tech/tags/tool-calling.md>), [web-applications](<https://devfeed.tech/tags/web-applications.md>)

### AI overview

This roundup highlights JobRunr 9 features for identifying failed steps and slow jobs, stopping runs without losing work, and starting jobs within milliseconds. It favors Spring Modulith's feature-based organization over traditional layered Spring Boot packages. Other items include a Spring learning roadmap, Progen CLI application scaffolding, IntelliJ IDEA features, Spring AI agentic patterns and tool calling, and a Bootiful Podcast conversation with Jenkins creator Kohsuke Kawaguchi.

### Source excerpt

Hi, Spring fans! Welcome to another rip-roarin' installment of This Week in Spring! This one I am writing from beautiful Carmel-by-the-Sea in sunny California's Bay Area, overlooking the Pacific Ocean. As I sit here, I'm enjoying a cup of coffee and bemusedly enjoying the amazing content in this week's roundup. We've got a ton of stuff to dive into, so let's do it! Have you seen the new features in Jobrunr 9? You can easily see which step failed, find the job behind a slowdown, stop a job run without losing work, and start jobs within milliseconds. It's awesome! (And it's on the Spring Initializr, too)! The GeeksforGeeks.org blog has a post about structuring a Spring Boot application and its packages. Unfortunately, it describes the traditional layered approach to architecture, and this is exactly how I would not layer my application. Instead, prefer Spring Modulith's approach, which allows you to rotate your layers 90 degrees and group things by feature, not by architectural layer. I don't know if I agree with everything in this roadmap on learning Spring, but I do like that somebody's tried to document it. An interesting watch by SivaLabs on scaffolding applications with Progen CLI Speaking of Siva, I was happy to sit with him and do a joint video looking at some of the new features in IntelliJ IDEA at the recent IntelliJ IDEA conf. A ton of fun, as always, and I hope you get something out of it At the same show, my friend and Spring AI lead Christian Tsolov looked at agentic patterns and tool calling with Spring AI - super interesting watch! I was thrilled to sit with legendary Java luminary Kohsuke Kawaguchi (creator of Jenkins!) and catch up in last week's installment of A Bootiful Podcast!

## An E-Commerce Platform Is a Reliability Problem Disguised as a Website Project

DevFeed: [An E-Commerce Platform Is a Reliability Problem Disguised as a Website Project](<https://devfeed.tech/articles/an-e-commerce-platform-is-a-reliability-problem-disguised-as-a-website-project-84431.md>)

Original publisher: [Read original article](<https://hackernoon.com/an-e-commerce-platform-is-a-reliability-problem-disguised-as-a-website-project?source=rss>)

Author: lou hackfun

Published: 2026-10-09T17:09:56Z

Content type: tutorial

Language: en

Sources: [HackerNoon](<https://devfeed.tech/sources/hackernoon.md>)

Topics: [Production Engineering](<https://devfeed.tech/topics/production-engineering.md>), [modular-monolith](<https://devfeed.tech/topics/modular-monolith.md>), [consistency](<https://devfeed.tech/topics/consistency.md>), [CockroachDB](<https://devfeed.tech/topics/cockroachdb.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [availability](<https://devfeed.tech/tags/availability.md>), [caching](<https://devfeed.tech/tags/caching.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [e-commerce](<https://devfeed.tech/tags/e-commerce.md>), [ecommerce](<https://devfeed.tech/tags/ecommerce.md>), [site-reliability-engineering](<https://devfeed.tech/tags/site-reliability-engineering.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [ux](<https://devfeed.tech/tags/ux.md>), [web-development](<https://devfeed.tech/tags/web-development.md>), [web-performance](<https://devfeed.tech/tags/web-performance.md>), [webdev](<https://devfeed.tech/tags/webdev.md>)

### AI overview

A practical guide to designing production e-commerce platforms around reliability as traffic, catalog size, and business rules grow. It covers domain boundaries, read and write workloads, caching, search, inventory consistency, checkout failures, idempotency, frontend error states, observability, performance measurement, security, and when to split a modular monolith into services.

### Source excerpt

Learn how to design a production-grade e-commerce web platform with clear domain boundaries, caching, search, inventory consistency, checkout reliability, obser

## Modular Jetpack Compose: Don't Leave Your Architecture to Code Review

DevFeed: [Modular Jetpack Compose: Don't Leave Your Architecture to Code Review](<https://devfeed.tech/articles/modular-jetpack-compose-don-t-leave-your-architecture-to-code-review-63717.md>)

Original publisher: [Read original article](<https://proandroiddev.com/modular-jetpack-compose-dont-leave-your-architecture-to-code-review-67b1b916097c?source=rss----c72404660798---4>)

Author: Kanan Yusubov

Published: 2026-10-02T04:56:58Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [modular-monolith](<https://devfeed.tech/topics/modular-monolith.md>), [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>), [decoupling](<https://devfeed.tech/topics/decoupling.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Jetpack](<https://devfeed.tech/topics/jetpack.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-architecture](<https://devfeed.tech/tags/android-architecture.md>), [api](<https://devfeed.tech/tags/api.md>), [api-impl](<https://devfeed.tech/tags/api-impl.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [build](<https://devfeed.tech/tags/build.md>), [ci](<https://devfeed.tech/tags/ci.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compose](<https://devfeed.tech/tags/compose.md>), [core](<https://devfeed.tech/tags/core.md>), [counter](<https://devfeed.tech/tags/counter.md>), [failure](<https://devfeed.tech/tags/failure.md>), [feature](<https://devfeed.tech/tags/feature.md>), [features](<https://devfeed.tech/tags/features.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [internals](<https://devfeed.tech/tags/internals.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [koin](<https://devfeed.tech/tags/koin.md>), [ktor](<https://devfeed.tech/tags/ktor.md>), [mobile-design-system](<https://devfeed.tech/tags/mobile-design-system.md>), [modular](<https://devfeed.tech/tags/modular.md>), [monorepo](<https://devfeed.tech/tags/monorepo.md>)

### AI overview

The article proposes enforcing modular Jetpack Compose architecture through Gradle and Kotlin rather than relying on review conventions. Each capability has an -api contract and an -impl module, with only the app allowed to depend on implementations; a shared Gradle guard checks all project dependency configurations. Kotlin internal visibility hides implementation details, while feature launchers expose routes without exposing route classes. Koin's compiler plugin checks dependency definitions at build time, and sealed result and failure types require exhaustive handling; cancellation is rethrown. A CI source check catches unregistered features and routes that compile-time checks miss, while a generator creates new feature wiring. The approach adds modules and navigation indirection; the author suggests it may suit apps with roughly ten features or multiple teams, while smaller apps may be fine with one module and discipline.

### Source excerpt

Every Android architecture diagram looks clean on day one. Features in boxes, arrows pointing down, a note in the README saying "features must not depend on each other." Then a deadline arrives. Someone needs the user's avatar on the checkout screen, the profile feature already has a UserRepository, and it's one import away. The build is green, the review is busy, and the arrow now points sideways. Six months later nobody can change the profile feature without breaking checkout. Folders and naming conventions describe an architecture. They don't enforce it. A rule that only lives in a README is a suggestion. This article takes six rules a modular Compose app usually lives by, and moves each one out of the README and into the build: Only the app may depend on an implementation. Enforced by a Gradle check. A module's internals stay private. Enforced by Kotlin's internal. Only a feature may build its own routes. Enforced by internal routes and launchers. Every dependency has a definition. Enforced by Koin's compiler plugin. Every failure is handled. Enforced by sealed types. Every feature and route is registered. Enforced by a source check that runs in CI. Where a rule can't be enforced, the last section makes the right way the easy way instead. The shape: every capability is two modules Each capability becomes a pair of Gradle modules: -api says what the capability can do. Interfaces only. -impl says how. Screens, view models, repositories, DTOs, wiring. app/ the only module that sees implementations features/ posts/posts-api PostsApi, PostsLauncher posts/posts-impl screens, view models, data, Koin module counter/counter-api counter/counter-impl depends on posts-api, never posts-impl core/ designsystem/ tokens, theme, components statemanager/ AppStateViewModel router/router-api | impl Navigation 3 network/network-api | impl Ktor logger/logger-api | impl Kermit Dependencies only point down: app -> features -> core. Features reach each other only through an -api. When che

## What I learned at DevTalks Cluj-Napoca 2026

DevFeed: [What I learned at DevTalks Cluj-Napoca 2026](<https://devfeed.tech/articles/what-i-learned-at-devtalks-cluj-napoca-2026-60202.md>)

Original publisher: [Read original article](<https://vladmihalcea.com/devtalks-cluj-napoca-2026/>)

Author: vladmihalcea

Published: 2026-09-25T19:10:03Z

Content type: article

Language: en

Sources: [Vlad Mihalcea](<https://devfeed.tech/sources/vlad-mihalcea.md>)

Topics: [Java](<https://devfeed.tech/topics/java.md>), [software-architecture](<https://devfeed.tech/topics/software-architecture.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [modular-monolith](<https://devfeed.tech/topics/modular-monolith.md>), [Hibernate](<https://devfeed.tech/topics/hibernate.md>), [Spring Boot](<https://devfeed.tech/topics/spring-boot.md>), [Microservices](<https://devfeed.tech/topics/microservices.md>), [Spring Framework](<https://devfeed.tech/topics/spring-framework.md>), [Software](<https://devfeed.tech/topics/software.md>), [Jakarta EE](<https://devfeed.tech/topics/jakarta-ee.md>)

Tags: [conference](<https://devfeed.tech/tags/conference.md>), [effective-learning](<https://devfeed.tech/tags/effective-learning.md>), [hibernate](<https://devfeed.tech/tags/hibernate.md>), [java](<https://devfeed.tech/tags/java.md>), [jpa](<https://devfeed.tech/tags/jpa.md>), [micronaut](<https://devfeed.tech/tags/micronaut.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [modular-monolith](<https://devfeed.tech/tags/modular-monolith.md>), [public-speaking](<https://devfeed.tech/tags/public-speaking.md>), [quarkus](<https://devfeed.tech/tags/quarkus.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [spring-boot](<https://devfeed.tech/tags/spring-boot.md>), [spring-framework](<https://devfeed.tech/tags/spring-framework.md>)

### AI overview

The author recounts attending DevTalks Cluj-Napoca 2026, moderating the Java track, giving a talk, and hosting a panel on Java software development in the age of AI. The article discusses sessions on software architecture, modular monoliths with Spring Modulith, and choosing a modular monolith rather than microservices for some Java applications.

### Source excerpt

Introduction On the 24th of September, I participated in the 9th edition of DevTalks Cluj-Napoca, and since I had a really great time attending this conference, I decided to share what I learned from attending sessions and having conversations with both speakers and participants. DevTalks DevTalks runs several conferences throughout Romania, and while the one in Bucharest is very large, featuring 14 stanges, we are lucky to have on in Cluj-Napoca, my home town, which manages to run 3 parallel tracks on which 40 speakers present their latest findings. This year, the... Read More The post What I learned at DevTalks Cluj-Napoca 2026 appeared first on Vlad Mihalcea.

## Orchestration Patterns for Multi-Agent Systems: Performance and Trade-offs

DevFeed: [Orchestration Patterns for Multi-Agent Systems: Performance and Trade-offs](<https://devfeed.tech/articles/orchestration-patterns-for-multi-agent-systems-performance-and-trade-offs-50203.md>)

Original publisher: [Read original article](<https://devblogs.microsoft.com/ise/coordinator-patterns-multi-agent-systems/>)

Author: Lily Jia

Published: 2026-06-12T07:00:00Z

Content type: article

Language: en

Sources: [ISE Developer Blog](<https://devfeed.tech/sources/ise-developer-blog.md>)

Topics: [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [agent orchestration](<https://devfeed.tech/topics/agent-orchestration.md>), [Orchestration](<https://devfeed.tech/topics/orchestration.md>), [Microservices](<https://devfeed.tech/topics/microservices.md>), [modular-monolith](<https://devfeed.tech/topics/modular-monolith.md>), [software-architecture](<https://devfeed.tech/topics/software-architecture.md>), [Chat Bot](<https://devfeed.tech/topics/chatbot.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [software-development](<https://devfeed.tech/topics/software-development.md>)

Tags: [agent-orchestration](<https://devfeed.tech/tags/agent-orchestration.md>), [ai](<https://devfeed.tech/tags/ai.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [chatbots](<https://devfeed.tech/tags/chatbots.md>), [cse](<https://devfeed.tech/tags/cse.md>), [development](<https://devfeed.tech/tags/development.md>), [ise](<https://devfeed.tech/tags/ise.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [microservices-architecture](<https://devfeed.tech/tags/microservices-architecture.md>), [modular-monolith](<https://devfeed.tech/tags/modular-monolith.md>), [multi-agent](<https://devfeed.tech/tags/multi-agent.md>), [multi-agent-systems](<https://devfeed.tech/tags/multi-agent-systems.md>), [orchestration](<https://devfeed.tech/tags/orchestration.md>), [scale](<https://devfeed.tech/tags/scale.md>)

### AI overview

A Microsoft ISE post describes evolving a production retail chatbot from a modular monolith with deterministic routing into a coordinator-based multi-agent architecture. It discusses agent reuse, independent services, organizational ownership, and performance trade-offs.

### Source excerpt

Real-world lessons from evolving a production chatbot into a coordinator-based multi-agent architecture, including performance trade-offs for enterprise-scale agent reuse. The post Orchestration Patterns for Multi-Agent Systems: Performance and Trade-offs appeared first on ISE Developer Blog.

## Mercari's Modular Monolith Infrastructure for Global Expansion

DevFeed: [Mercari's Modular Monolith Infrastructure for Global Expansion](<https://devfeed.tech/articles/behind-the-infrastructure-powering-global-expansion-56765.md>)

Original publisher: [Read original article](<https://engineering.mercari.com/en/blog/entry/20251007-behind-the-infrastructure-powering-global-expansion/>)

Author: Yanolab

Published: 2025-10-08T12:00:41Z

Content type: article

Language: en

Sources: [Mercari Engineering](<https://devfeed.tech/sources/mercari-engineering.md>)

Topics: [Microservices](<https://devfeed.tech/topics/microservices.md>), [modular-monolith](<https://devfeed.tech/topics/modular-monolith.md>), [Back end](<https://devfeed.tech/topics/backend.md>), [site-reliability-engineering](<https://devfeed.tech/topics/site-reliability-engineering.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Terraform](<https://devfeed.tech/topics/terraform.md>), [Kubernetes](<https://devfeed.tech/topics/kubernetes.md>), [SDK](<https://devfeed.tech/topics/sdk.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [backend](<https://devfeed.tech/tags/backend.md>), [ci-cd](<https://devfeed.tech/tags/ci-cd.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [modular-monolith](<https://devfeed.tech/tags/modular-monolith.md>), [sre](<https://devfeed.tech/tags/sre.md>)

### AI overview

Mercari's Cross Border Engineering team describes rebuilding infrastructure for global expansion with a modular monolith designed to retain the benefits of its microservice ecosystem while enabling microservice-like operations. The article discusses Go microservice SDKs, Terraform modules, Kubernetes deployment abstractions, CI/CD constraints, and production readiness processes.

### Source excerpt

I'm yanolab, working as an Architect and SRE in Cross Border (XB) Engineering. On the first day of this blog series, we introduced Rebuilding App and Foundation for Global Expansion. In this article, titled "Behind the Scenes of Infrastructure Supporting Global Expansion," I'd like to delve a bit deeper into the architecture, frameworks, and initiatives [...]

## Angular Architecture Guide To Building Maintainable Applications at Scale

DevFeed: [Angular Architecture Guide To Building Maintainable Applications at Scale](<https://devfeed.tech/articles/angular-architecture-guide-to-building-maintainable-applications-at-scale-21398.md>)

Original publisher: [Read original article](<https://nx.dev/blog/architecting-angular-applications>)

Author: Juri Strumpflohner

Published: 2025-03-18T00:00:00Z

Content type: article

Language: en

Sources: [Juri Strumpflohner](<https://devfeed.tech/sources/juri-strumpflohner.md>)

Topics: [Angular](<https://devfeed.tech/topics/angular.md>), [software-architecture](<https://devfeed.tech/topics/software-architecture.md>), [Domain-driven design (DDD)](<https://devfeed.tech/topics/domain-driven-design.md>), [Microservices](<https://devfeed.tech/topics/microservices.md>), [Developer Tools](<https://devfeed.tech/topics/developer-tools.md>), [modular-monolith](<https://devfeed.tech/topics/modular-monolith.md>)

Tags: [applications](<https://devfeed.tech/tags/applications.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [aspect](<https://devfeed.tech/tags/aspect.md>), [automate](<https://devfeed.tech/tags/automate.md>), [best-practices](<https://devfeed.tech/tags/best-practices.md>), [building](<https://devfeed.tech/tags/building.md>), [business](<https://devfeed.tech/tags/business.md>), [capabilities](<https://devfeed.tech/tags/capabilities.md>), [code](<https://devfeed.tech/tags/code.md>), [conway](<https://devfeed.tech/tags/conway.md>), [conway-s-law](<https://devfeed.tech/tags/conway-s-law.md>), [customer](<https://devfeed.tech/tags/customer.md>), [design](<https://devfeed.tech/tags/design.md>), [domain](<https://devfeed.tech/tags/domain.md>), [domain-driven-design](<https://devfeed.tech/tags/domain-driven-design.md>), [e-commerce](<https://devfeed.tech/tags/e-commerce.md>), [key-angular](<https://devfeed.tech/tags/key-angular.md>), [key-architecture](<https://devfeed.tech/tags/key-architecture.md>), [maintainability](<https://devfeed.tech/tags/maintainability.md>), [scale](<https://devfeed.tech/tags/scale.md>), [team](<https://devfeed.tech/tags/team.md>), [team-collaboration](<https://devfeed.tech/tags/team-collaboration.md>)

### AI overview

The excerpt recommends structuring Angular code around business domains rather than technical types such as components and services. Domains should reflect distinct capabilities, have clear responsibilities, evolve independently, and may mirror team organization; examples include Products, Orders, Checkout, and User Management. This vertical organization complements layered, hexagonal, or onion approaches that separate technical responsibilities. The goal is modularity, encapsulation, and clear boundaries so teams can make incremental changes, keep decisions reversible, and adapt as requirements become clearer. The excerpt says the article also addresses development-time structure and automating best practices, but provides no specific Nx implementation details.

### Source excerpt

Learn how to build scalable Angular applications using domain-driven design, clear boundaries, and Nx tooling for better maintainability and team collaboration.

## How we improved push processing on GitHub

DevFeed: [How we improved push processing on GitHub](<https://devfeed.tech/articles/how-we-improved-push-processing-on-github-67719.md>)

Original publisher: [Read original article](<https://github.blog/engineering/architecture-optimization/how-we-improved-push-processing-on-github/>)

Author: Will Haltom

Published: 2024-06-11T17:00:33Z

Content type: article

Language: en

Sources: [GitHub Blog](<https://devfeed.tech/sources/github-engineering.md>), [GitHub Engineering](<https://devfeed.tech/sources/github.md>)

Topics: [GitHub](<https://devfeed.tech/topics/github.md>), [Confluent Cloud](<https://devfeed.tech/topics/confluent-cloud.md>), [modular-monolith](<https://devfeed.tech/topics/modular-monolith.md>), [Data pipelines](<https://devfeed.tech/topics/data-pipelines.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [architecture-optimization](<https://devfeed.tech/tags/architecture-optimization.md>), [broker](<https://devfeed.tech/tags/broker.md>), [cluster](<https://devfeed.tech/tags/cluster.md>), [decoupling](<https://devfeed.tech/tags/decoupling.md>), [define](<https://devfeed.tech/tags/define.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [github](<https://devfeed.tech/tags/github.md>), [github-actions](<https://devfeed.tech/tags/github-actions.md>), [how-github-builds-github](<https://devfeed.tech/tags/how-github-builds-github.md>)

### AI overview

GitHub describes replacing a large sequential RepositoryPushJob with Kafka events and independent background jobs. The change separated retries and ownership by task, reduced dependencies on the Pushes MySQL cluster, improved observability, and lowered latency. The article reports a worst-case estimate of 99.999% of pushes fully processed in the new pipeline, compared with about 99.897% in the previous system.

### Source excerpt

Pushing code to GitHub is one of the most fundamental interactions that developers have with GitHub every day. Read how we have significantly improved the ability of our monolith to correctly and fully process pushes from our users.

## Modularizing Rails Monoliths One Bite at a Time

DevFeed: [Modularizing Rails Monoliths One Bite at a Time](<https://devfeed.tech/articles/modularizing-rails-monoliths-one-bite-at-a-time-20038.md>)

Original publisher: [Read original article](<https://technology.doximity.com/articles/modularizing-rails-monoliths-one-bite-at-a-time>)

Author: Doximity

Published: 2023-12-05T13:00:00Z

Content type: article

Language: en

Sources: [Doximity](<https://devfeed.tech/sources/doximity.md>)

Topics: [modular-monolith](<https://devfeed.tech/topics/modular-monolith.md>), [Ruby on Rails](<https://devfeed.tech/topics/ruby-on-rails.md>), [software-architecture](<https://devfeed.tech/topics/software-architecture.md>), [monolithic-architecture](<https://devfeed.tech/topics/monolithic-architecture.md>)

Tags: [conference](<https://devfeed.tech/tags/conference.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [modular-monolith](<https://devfeed.tech/tags/modular-monolith.md>), [modularization](<https://devfeed.tech/tags/modularization.md>), [podcast](<https://devfeed.tech/tags/podcast.md>), [rails](<https://devfeed.tech/tags/rails.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [ruby](<https://devfeed.tech/tags/ruby.md>)

### AI overview

As Rails monoliths grow, tighter coupling can make them harder to manage, while moving to microservices can add complexity. A modular monolith offers enforced boundaries with less overhead. The author describes a phased refactoring approach using the packwerk gem and says Doximity used it to split critical Rails applications into modules that are easier for teams to work with.

### Source excerpt

As Rails monoliths grow, coupling becomes increasingly difficult to manage. Developers often reach for microservices to help simplify things, but instead find higher complexity. The Modular Monolith approach is a proven, lightweight alternative that offers the benefits of enforced boundaries without being cumbersome. I spoke at the 2023 Rocky Mountain Ruby conference on how teams can use a phased approach to refactoring toward this style using the packwerk gem. At Doximity, we've used this gem and a phased approach to break some of our most critical rails applications into modules that are easier for our teams to work with. In November, 2023, I also chatted with Elise Shaffer on The Ruby on Rails Podcast about our experience with application modularization at Doximity. Be sure to follow @doximity_tech if you'd like to be notified about new blog posts.

## In defense of simple architectures

DevFeed: [In defense of simple architectures](<https://devfeed.tech/articles/in-defense-of-simple-architectures-77743.md>)

Original publisher: [Read original article](<https://danluu.com/simple-architectures/>)

Published: 2022-04-06T00:00:00Z

Content type: opinion

Language: en

Sources: [Danluu](<https://devfeed.tech/sources/danluu.md>)

Topics: [modular-monolith](<https://devfeed.tech/topics/modular-monolith.md>), [backend frameworks](<https://devfeed.tech/topics/backend-frameworks.md>), [Product Management](<https://devfeed.tech/topics/product-management.md>), [locking](<https://devfeed.tech/topics/locking.md>)

Tags: [architectures](<https://devfeed.tech/tags/architectures.md>), [build](<https://devfeed.tech/tags/build.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [database](<https://devfeed.tech/tags/database.md>), [monolith](<https://devfeed.tech/tags/monolith.md>), [postgres](<https://devfeed.tech/tags/postgres.md>), [python](<https://devfeed.tech/tags/python.md>)

### AI overview

Wave describes how it keeps its backend architecture simple, using a Python monolith on Postgres and adding complexity only where business needs justify it. The article discusses tradeoffs in asynchronous processing, database transactions, vendor software, GraphQL, Kubernetes, and telecom integrations, and argues that engineering effort should focus on complexity that benefits the business.

### Source excerpt

Wave is a $1.7B company with 70 engineers1 whose product is a CRUD app that adds and subtracts numbers. In keeping with this, our architecture is a standard CRUD app architecture, a Python monolith on top of Postgres. Starting with a simple architecture and solving problems in simple ways where possible has allowed us to scale to this size while engineers mostly focus on work that delivers value to users. Stackoverflow scaled up a monolith to good effect (2013 architecture / 2016 architecture), eventually getting acquired for $1.8B. If we look at traffic instead of market cap, Stackoverflow is among the top 100 highest traffic sites on the internet (for many other examples of valuable companies that were built on top of monoliths, see the replies to this Twitter thread. We don't have a lot of web traffic because we're a mobile app, but Alexa still puts our website in the top 75k even though our website is basically just a way for people to find the app and most people don't even find the app through our website). There are some kinds of applications that have demands that would make a simple monolith on top of a boring database a non-starter but, for most kinds of applications, even at top-100 site levels of traffic, computers are fast enough that high-traffic apps can be served with simple architectures, which can generally be created more cheaply and easily than complex architectures. Despite the unreasonable effectiveness of simple architectures, most press goes to complex architectures. For example, at a recent generalist tech conference, there were six talks on how to build or deal with side effects of complex, microservice-based, architectures and zero on how one might build out a simple monolith. There were more talks on quantum computing (one) than talks on monoliths (zero). Larger conferences are similar; a recent enterprise-oriented conference in SF had a double-digit number of talks on dealing with the complexity of a sophisticated architecture and zero o

## The Service-Oriented Architecture Tradeoffs

DevFeed: [The Service-Oriented Architecture Tradeoffs](<https://devfeed.tech/articles/the-service-oriented-architecture-tradeoffs-17842.md>)

Original publisher: [Read original article](<https://encore.dev/blog/service-oriented-tradeoffs>)

Author: André Eriksson

Published: 2020-02-26T00:00:00Z

Content type: article

Language: en

Sources: [Encore Updates](<https://devfeed.tech/sources/encore-updates.md>)

Topics: [software-architecture](<https://devfeed.tech/topics/software-architecture.md>), [Microservices](<https://devfeed.tech/topics/microservices.md>), [architecture-components](<https://devfeed.tech/topics/architecture-components.md>), [modular-monolith](<https://devfeed.tech/topics/modular-monolith.md>), [software-development](<https://devfeed.tech/topics/software-development.md>), [Maintainability](<https://devfeed.tech/topics/maintainability.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [developer-productivity](<https://devfeed.tech/tags/developer-productivity.md>), [interfaces](<https://devfeed.tech/tags/interfaces.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [monolith](<https://devfeed.tech/tags/monolith.md>), [ownership](<https://devfeed.tech/tags/ownership.md>), [service-oriented-architecture](<https://devfeed.tech/tags/service-oriented-architecture.md>), [tradeoffs](<https://devfeed.tech/tags/tradeoffs.md>)

### AI overview

The excerpt presents the monolith-versus-microservices choice as a context-dependent tradeoff. Clear component interfaces and ownership matter in either architecture: interfaces are easier to change within a service, where compilers can catch misuse and versioning is unnecessary, while separate services more naturally establish responsibility and ownership. Components inside a larger service can blur ownership when different teams work across their boundaries. The excerpt begins to introduce fast feedback loops as another consideration but ends before explaining that tradeoff.

### Source excerpt

Understand the pros and cons on the spectrum from monolith to microservices, and how you can make informed decisions about how to architect your application.