# monolith

Published articles for monolith.

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

## How to Migrate a Legacy Monolith Incrementally Without a Big-Bang Rewrite

DevFeed: [How to Migrate a Legacy Monolith Incrementally Without a Big-Bang Rewrite](<https://devfeed.tech/articles/how-to-migrate-a-legacy-monolith-incrementally-without-a-big-bang-rewrite-42754.md>)

Original publisher: [Read original article](<https://www.freecodecamp.org/news/migrate-legacy-monolith-incrementally/>)

Author: Hugo Teijiz

Published: 2026-09-17T23:27:03Z

Content type: tutorial

Language: en

Sources: [freeCodeCamp Programming Tutorials: Python, JavaScript, Git & More](<https://devfeed.tech/sources/freecodecamp-programming-tutorials-python-javascript-git-more.md>)

Topics: [Legacy Modernization](<https://devfeed.tech/topics/legacy-modernization.md>), [migration](<https://devfeed.tech/topics/migration.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [Testing](<https://devfeed.tech/topics/testing.md>), [Integration testing](<https://devfeed.tech/topics/integration-testing.md>), [observability](<https://devfeed.tech/topics/observability.md>), [Routing (disambiguation)](<https://devfeed.tech/topics/routing.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [TypeScript](<https://devfeed.tech/topics/typescript.md>), [API](<https://devfeed.tech/topics/api.md>), [service](<https://devfeed.tech/topics/service.md>), [Dependency injection](<https://devfeed.tech/topics/dependency-injection.md>)

Tags: [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [incremental](<https://devfeed.tech/tags/incremental.md>), [integration-testing](<https://devfeed.tech/tags/integration-testing.md>), [legacy](<https://devfeed.tech/tags/legacy.md>), [legacy-code](<https://devfeed.tech/tags/legacy-code.md>), [migrate](<https://devfeed.tech/tags/migrate.md>), [migration](<https://devfeed.tech/tags/migration.md>), [monolith](<https://devfeed.tech/tags/monolith.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [rewrite](<https://devfeed.tech/tags/rewrite.md>), [routing](<https://devfeed.tech/tags/routing.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

A tutorial on migrating a legacy monolith incrementally by moving one business capability at a time. It covers characterization tests, boundaries between legacy and new code, parallel implementations, progressive traffic, observability, rollback paths, data ownership, and removing migrated behavior.

### Source excerpt

Large legacy migrations often fail long before the final cutover. The failure usually starts when the migration is framed as a single event. Move the application. Move the database. Move all the users

## When Microservice Decomposition Is the Wrong Default

DevFeed: [When Microservice Decomposition Is the Wrong Default](<https://devfeed.tech/articles/when-microservice-decomposition-is-the-wrong-default-34109.md>)

Original publisher: [Read original article](<https://philipptheserver.com/posts/microservice-decomposition-heuristic/>)

Author: Philipp Lehmann (philipp.lehmann@gruppe.ai)

Published: 2026-08-21T07:00:00Z

Content type: opinion

Language: en

Sources: [Philipp Lehmann](<https://devfeed.tech/sources/philipp-lehmann.md>)

Topics: [Microservice](<https://devfeed.tech/topics/microservice.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Microservices](<https://devfeed.tech/topics/microservices.md>), [FastAPI](<https://devfeed.tech/topics/fastapi.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [circuit](<https://devfeed.tech/tags/circuit.md>), [docker](<https://devfeed.tech/tags/docker.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [migration](<https://devfeed.tech/tags/migration.md>), [modular-monolith](<https://devfeed.tech/tags/modular-monolith.md>), [monolith](<https://devfeed.tech/tags/monolith.md>), [openapi](<https://devfeed.tech/tags/openapi.md>), [tracing](<https://devfeed.tech/tags/tracing.md>)

### AI overview

The article argues that splitting a small system into microservices should not be the default. It recommends keeping responsibilities in a modular monolith unless differences in scaling needs, organizational boundaries, or failure isolation justify a network boundary, whose costs include contracts, compatibility management, retries, timeouts, circuit breaking, and distributed tracing.

### Source excerpt

import-linter forbidden contract as a module boundary: a FastAPI modular monolith instead of early microservices, and when a network split pays off.

## Modular Monoliths: Creating Real Boundaries Before Reaching for Microservices

DevFeed: [Modular Monoliths: Creating Real Boundaries Before Reaching for Microservices](<https://devfeed.tech/articles/modular-monoliths-creating-real-boundaries-before-reaching-for-microservices-33296.md>)

Original publisher: [Read original article](<https://freek.dev/3182-modular-monoliths-creating-real-boundaries-before-reaching-for-microservices>)

Author: Freek Van der Herten (freek@spatie.be)

Published: 2026-08-20T13:48:25Z

Content type: article

Language: en

Sources: [freek.dev - all blogposts](<https://devfeed.tech/sources/freek-dev-all-blogposts.md>)

Topics: [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Microservice](<https://devfeed.tech/topics/microservice.md>), [Database](<https://devfeed.tech/topics/database.md>)

Tags: [apis](<https://devfeed.tech/tags/apis.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [database](<https://devfeed.tech/tags/database.md>), [design-patterns](<https://devfeed.tech/tags/design-patterns.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [migration](<https://devfeed.tech/tags/migration.md>), [modular](<https://devfeed.tech/tags/modular.md>), [monolith](<https://devfeed.tech/tags/monolith.md>), [tests](<https://devfeed.tech/tags/tests.md>)

### AI overview

This article examines modular monoliths as a way to establish real architectural boundaries before adopting microservices. It covers module APIs, database ownership, cross-module communication, architecture tests, incremental migration, and signals that may justify a move to microservices.

### Source excerpt

A deep dive into modular monoliths, from module APIs and database ownership to cross-module communication, architecture tests, incremental migration, and the signals that justify microservices. Read more

## Strategies for Migrating from a Monolith to Microservices

DevFeed: [Strategies for Migrating from a Monolith to Microservices](<https://devfeed.tech/articles/monolith-to-service-architecture-34687.md>)

Original publisher: [Read original article](<https://newsletter.systemdesigncodex.com/p/monolith-to-service-architecture>)

Author: Saurabh Dashora

Published: 2026-06-23T07:55:12Z

Content type: tutorial

Language: en

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

Topics: [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [microservices architecture](<https://devfeed.tech/topics/microservices-architecture.md>), [migration](<https://devfeed.tech/topics/migration.md>), [legacy systems](<https://devfeed.tech/topics/legacy-systems.md>), [gateway](<https://devfeed.tech/topics/gateway.md>)

Tags: [api-gateway](<https://devfeed.tech/tags/api-gateway.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [automated](<https://devfeed.tech/tags/automated.md>), [big-bang](<https://devfeed.tech/tags/big-bang.md>), [feature-flags](<https://devfeed.tech/tags/feature-flags.md>), [incremental](<https://devfeed.tech/tags/incremental.md>), [legacy-systems](<https://devfeed.tech/tags/legacy-systems.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [migration](<https://devfeed.tech/tags/migration.md>), [monolith](<https://devfeed.tech/tags/monolith.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [rewrite](<https://devfeed.tech/tags/rewrite.md>), [strategies](<https://devfeed.tech/tags/strategies.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

This tutorial outlines patterns for gradually moving from a monolithic architecture to microservices. It describes the Strangler Fig Pattern, Parallel Run Pattern, and Collaborator Pattern, covering techniques such as API gateways, incremental migration, traffic splitting, feature flags, and automated comparison testing.

### Source excerpt

Top Strategies

## Strategies for Moving from a Monolith to Microservices

DevFeed: [Strategies for Moving from a Monolith to Microservices](<https://devfeed.tech/articles/how-to-move-from-monolith-to-a-service-based-architecture-34682.md>)

Original publisher: [Read original article](<https://newsletter.systemdesigncodex.com/p/how-to-move-from-monolith-to-a-service>)

Author: Saurabh Dashora

Published: 2026-05-26T07:58:51Z

Content type: tutorial

Language: en

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

Topics: [microservices architecture](<https://devfeed.tech/topics/microservices-architecture.md>), [migration](<https://devfeed.tech/topics/migration.md>), [legacy systems](<https://devfeed.tech/topics/legacy-systems.md>), [proxy](<https://devfeed.tech/topics/proxy.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [big-bang](<https://devfeed.tech/tags/big-bang.md>), [feature-flags](<https://devfeed.tech/tags/feature-flags.md>), [incremental](<https://devfeed.tech/tags/incremental.md>), [monolith](<https://devfeed.tech/tags/monolith.md>)

### AI overview

This tutorial describes patterns for gradually moving from a monolithic architecture to microservices. It covers the Strangler Fig Pattern, Parallel Run Pattern, and Collaborator Pattern in the supplied text, emphasizing incremental migration, traffic splitting, behavior comparison, feature flags, and reduced rewrite risk.

### Source excerpt

Strategies worth knowing

## Monolith vs Microservices vs Modular Monoliths

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

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

Author: Ashish Pratap Singh

Published: 2026-05-12T04:10:14Z

Content type: article

Language: en

Sources: [AlgoMaster Newsletter](<https://devfeed.tech/sources/algomaster-newsletter.md>)

Topics: [Software](<https://devfeed.tech/topics/software.md>), [Microservice](<https://devfeed.tech/topics/microservice.md>), [Database](<https://devfeed.tech/topics/database.md>)

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

### AI overview

The document introduces software systems that begin with a small team, a single codebase, one database, and a few features, in the context of comparing monoliths, microservices, and modular monoliths.

### Source excerpt

Most software systems start simple. A small team, a single codebase, one database, and a few features.

## Top 10 API Gateway Use Cases in System Design

DevFeed: [Top 10 API Gateway Use Cases in System Design](<https://devfeed.tech/articles/top-10-api-gateway-use-cases-in-system-design-33577.md>)

Original publisher: [Read original article](<https://blog.algomaster.io/p/top-10-api-gateway-use-cases>)

Author: Ashish Pratap Singh

Published: 2026-04-12T12:00:32Z

Content type: tutorial

Language: en

Sources: [AlgoMaster Newsletter](<https://devfeed.tech/sources/algomaster-newsletter.md>)

Topics: [Amazon API Gateway](<https://devfeed.tech/topics/amazon-api-gateway.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Microservices](<https://devfeed.tech/topics/microservices.md>), [API](<https://devfeed.tech/topics/api.md>)

Tags: [api-gateway](<https://devfeed.tech/tags/api-gateway.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [monolith](<https://devfeed.tech/tags/monolith.md>), [system-design](<https://devfeed.tech/tags/system-design.md>), [use-cases](<https://devfeed.tech/tags/use-cases.md>)

### AI overview

An article about ten API gateway use cases in system design, particularly as systems evolve from monoliths to microservices. The supplied evidence does not detail the individual use cases.

### Source excerpt

As your system evolves from a monolith to microservices, a pattern quickly emerges: every service starts rebuilding the same things.

## Choosing the Right Granularity for Microservices: Klarna's Payments Architecture Journey

DevFeed: [Choosing the Right Granularity for Microservices: Klarna's Payments Architecture Journey](<https://devfeed.tech/articles/how-micro-should-your-microservices-be-35650.md>)

Original publisher: [Read original article](<https://engineering.klarna.com/how-micro-should-your-microservices-be-9ae7507a625c?source=rss----86090d14ab52---4>)

Author: Raya Rizk

Published: 2025-03-24T07:22:27Z

Content type: article

Language: en

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

Topics: [Microservices](<https://devfeed.tech/topics/microservices.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Development](<https://devfeed.tech/topics/development.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Scalability](<https://devfeed.tech/topics/scalability.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [challenges](<https://devfeed.tech/tags/challenges.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [klarna](<https://devfeed.tech/tags/klarna.md>), [led](<https://devfeed.tech/tags/led.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [modular-monolith](<https://devfeed.tech/tags/modular-monolith.md>), [monolith](<https://devfeed.tech/tags/monolith.md>), [organizational-structure](<https://devfeed.tech/tags/organizational-structure.md>), [scalability](<https://devfeed.tech/tags/scalability.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>)

### AI overview

This article describes Klarna's transition from a monolithic architecture to payment-specific microservices and examines the trade-offs of service granularity. It reports that independently managed services improved team autonomy and development speed, while duplicated shared functionality created a complex distributed monolith.

### Source excerpt

Our journey towards striking the right balance The debate between monolithic and microservices architectures is a hot topic in software development. While monolithic systems are known for their simplicity and tightly integrated structure, they face challenges with scaling and flexibility. In contrast, microservices offer greater scalability and autonomy in development, but carry complexity in inter-service interactions. In this article, I'll share our experience in navigating between these two paradigms while working on a recent project at Klarna, exploring different architectural decisions while addressing a fundamental question: what is the optimal granularity for a microservice? From monolith to microservices: the company is growing 🚀 A monolithic architecture is often the natural starting point for businesses, serving well initially but revealing its limitations as organizations scale. Klarna was no exception. Like many in the IT industry, the company embraced the microservices paradigm alongside its rapid growth a few years ago. In the payments domain, we are focused on offering customers various payment options, allowing them to choose between paying directly, later, over time, or through other tailored methods. This demand for diverse options led each payment method to evolve into a distinct microservice, managed by dedicated teams. Each payment service acts as a key orchestrator in the purchase flow, coordinating with other services to guide customers through the required steps until order completion. This adoption of microservices naturally aligned with the company's organizational structure, offering team autonomy and the ability to scale services independently. Each service was self-contained, with its own database and code residing in a separate repository. By decoupling payment options into distinct services, we gained greater flexibility and enabled faster development cycles, as teams could focus on their respective components. Landing the distributed

## Modernizing monoliths with Temporal

DevFeed: [Modernizing monoliths with Temporal](<https://devfeed.tech/articles/modernizing-monoliths-with-temporal-35919.md>)

Original publisher: [Read original article](<https://temporal.io/blog/modernizing-monoliths-with-temporal>)

Author: Meagan Speare

Published: 2024-10-30T04:00:00Z

Content type: tutorial

Language: en

Sources: [Temporal Blog](<https://devfeed.tech/sources/temporal-blog.md>)

Topics: [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Domain-driven design (DDD)](<https://devfeed.tech/topics/domain-driven-design.md>), [Microservice](<https://devfeed.tech/topics/microservice.md>), [maintenance](<https://devfeed.tech/topics/maintenance.md>)

Tags: [cognitive-load](<https://devfeed.tech/tags/cognitive-load.md>), [domain-driven-design](<https://devfeed.tech/tags/domain-driven-design.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [modernizing](<https://devfeed.tech/tags/modernizing.md>), [monolith](<https://devfeed.tech/tags/monolith.md>), [scalability](<https://devfeed.tech/tags/scalability.md>), [temporal-concepts](<https://devfeed.tech/tags/temporal-concepts.md>)

### AI overview

This article explains how Temporal can help teams modernize monolithic systems without immediately breaking them into microservices. It recommends understanding the monolith through domains, bounded contexts, entities, relationships, and a shared language, while discussing motivations such as agility, scalability, cognitive load, quality, unclear responsibilities, and time to value.

### Source excerpt

Break down your monolith, or improve your monolith, by adopting Temporal

## How coupling distinguishes monoliths, microservices, and serverless architectures

DevFeed: [How coupling distinguishes monoliths, microservices, and serverless architectures](<https://devfeed.tech/articles/monoliths-microservices-and-serverless-aren-t-what-you-think-they-are-39078.md>)

Original publisher: [Read original article](<https://blog.devdetails.com/p/monoliths-microservices-and-serverless>)

Author: Mike

Published: 2024-01-19T05:42:25Z

Content type: opinion

Language: en

Sources: [Dev Details](<https://devfeed.tech/sources/dev-details.md>)

Topics: [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Microservice](<https://devfeed.tech/topics/microservice.md>), [Microservices](<https://devfeed.tech/topics/microservices.md>), [Serverless](<https://devfeed.tech/topics/serverless.md>), [Databases](<https://devfeed.tech/topics/databases.md>), [DynamoDB](<https://devfeed.tech/topics/dynamodb.md>)

Tags: [coupling](<https://devfeed.tech/tags/coupling.md>), [database](<https://devfeed.tech/tags/database.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [dynamodb](<https://devfeed.tech/tags/dynamodb.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [monolith](<https://devfeed.tech/tags/monolith.md>), [serverless](<https://devfeed.tech/tags/serverless.md>)

### AI overview

This article examines how to distinguish monoliths, microservices, and serverless architectures. It argues that deployment coupling and dependencies matter more than the number of repositories, containers, lambdas, teams, or database servers. Applications that must be redeployed together are described as parts of a distributed monolith, while microservices are characterized by how tightly coupled they are to dependencies, one another, and data.

### Source excerpt

Or are they?

## How to create exceptional communication with mobile engineering teams

DevFeed: [How to create exceptional communication with mobile engineering teams](<https://devfeed.tech/articles/how-to-create-exceptional-communication-with-mobile-engineering-teams-35081.md>)

Original publisher: [Read original article](<https://novoda.com/blog/2023/08/21/how-to-create-exceptional-communication-with-mobile-engineering-teams/>)

Author: Sarah Gruneisen

Published: 2023-08-21T09:19:33Z

Content type: tutorial

Language: en

Sources: [Novoda](<https://devfeed.tech/sources/novoda.md>)

Topics: [Mobile](<https://devfeed.tech/topics/mobile.md>), [mobile devops](<https://devfeed.tech/topics/mobile-devops.md>), [Development](<https://devfeed.tech/topics/development.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>)

Tags: [apps](<https://devfeed.tech/tags/apps.md>), [communication](<https://devfeed.tech/tags/communication.md>), [devops](<https://devfeed.tech/tags/devops.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [hybrid](<https://devfeed.tech/tags/hybrid.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [mobile-devops](<https://devfeed.tech/tags/mobile-devops.md>), [mobile-engineering](<https://devfeed.tech/tags/mobile-engineering.md>), [monolith](<https://devfeed.tech/tags/monolith.md>), [native](<https://devfeed.tech/tags/native.md>)

### AI overview

This article examines why mobile engineering teams become siloed, including organizational structures, remote and hybrid work, and the monolithic nature of mobile apps. It explains how Mobile DevOps can help bridge operational gaps and outlines principles for improving communication within mobile teams and across an organization.

### Source excerpt

We explore the reasons why mobile teams get siloed, how Mobile DevOps aims to bridge the operational gap between teams, and the key principles of exceptional communication within mobile teams and organisations as a whole. The post How to create exceptional communication with mobile engineering teams appeared first on Novoda.

## To choreograph or orchestrate your saga, that is the question

DevFeed: [To choreograph or orchestrate your saga, that is the question](<https://devfeed.tech/articles/to-choreograph-or-orchestrate-your-saga-that-is-the-question-36076.md>)

Original publisher: [Read original article](<https://temporal.io/blog/to-choreograph-or-orchestrate-your-saga-that-is-the-question>)

Author: Emily Fortuna

Published: 2023-07-13T15:30:00Z

Content type: article

Language: en

Sources: [Temporal Blog](<https://devfeed.tech/sources/temporal-blog.md>)

Topics: [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>), [microservices architecture](<https://devfeed.tech/topics/microservices-architecture.md>), [Orchestration](<https://devfeed.tech/topics/orchestration.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [business logic](<https://devfeed.tech/topics/business-logic.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [backend](<https://devfeed.tech/tags/backend.md>), [debug](<https://devfeed.tech/tags/debug.md>), [decoupling](<https://devfeed.tech/tags/decoupling.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [microservices-architecture](<https://devfeed.tech/tags/microservices-architecture.md>), [monolith](<https://devfeed.tech/tags/monolith.md>), [orchestration](<https://devfeed.tech/tags/orchestration.md>), [ordering](<https://devfeed.tech/tags/ordering.md>)

### AI overview

This article explains the saga pattern for tasks that span microservice boundaries and compares choreography with orchestration. It describes how choreography uses message passing and local service knowledge, while distributed ordering requirements can make control flow harder to understand and debug.

### Source excerpt

An explanation of orchestration and choreography of microservices, and how Temporal works under the hood. Find out how and why.

## Imperfect #14: How to map dependencies

DevFeed: [Imperfect #14: How to map dependencies](<https://devfeed.tech/articles/imperfect-14-how-to-map-dependencies-39452.md>)

Original publisher: [Read original article](<https://imperfect.substack.com/p/imperfect-14-how-to-map-dependencies>)

Author: Pedro Gil Carvalho

Published: 2023-07-07T13:33:59Z

Content type: tutorial

Language: en

Sources: [Pedro Gil Carvalho](<https://devfeed.tech/sources/pedro-gil-carvalho.md>)

Topics: [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [microservices architecture](<https://devfeed.tech/topics/microservices-architecture.md>), [Microservice](<https://devfeed.tech/topics/microservice.md>), [interfaces](<https://devfeed.tech/topics/interfaces.md>), [API](<https://devfeed.tech/topics/api.md>), [Database](<https://devfeed.tech/topics/database.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [awareness](<https://devfeed.tech/tags/awareness.md>), [changes](<https://devfeed.tech/tags/changes.md>), [database](<https://devfeed.tech/tags/database.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [issue-tracker](<https://devfeed.tech/tags/issue-tracker.md>), [map](<https://devfeed.tech/tags/map.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [microservices-architecture](<https://devfeed.tech/tags/microservices-architecture.md>), [monitor](<https://devfeed.tech/tags/monitor.md>), [monolith](<https://devfeed.tech/tags/monolith.md>), [pair-programming](<https://devfeed.tech/tags/pair-programming.md>)

### AI overview

The article explains how to map service dependencies to help identify and avoid distributed monoliths. It recommends team-by-team architecture reviews, collaboratively maintained diagrams, monitoring connected interfaces, and tracking dependencies in a simple spreadsheet.

### Source excerpt

Avoiding the distributed monolith antipattern requires great situational awareness. Today we go over what that means, how architecture reviews can help, and one simple way to anticipate dependencies.

## Imperfect #13: Killing the Distributed Monolith

DevFeed: [Imperfect #13: Killing the Distributed Monolith](<https://devfeed.tech/articles/imperfect-13-killing-the-distributed-monolith-39451.md>)

Original publisher: [Read original article](<https://imperfect.substack.com/p/imperfect-13-killing-the-distributed>)

Author: Pedro Gil Carvalho

Published: 2023-06-30T09:03:26Z

Content type: opinion

Language: en

Sources: [Pedro Gil Carvalho](<https://devfeed.tech/sources/pedro-gil-carvalho.md>)

Topics: [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [microservices architecture](<https://devfeed.tech/topics/microservices-architecture.md>), [Microservices](<https://devfeed.tech/topics/microservices.md>)

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

### AI overview

The article argues that a distributed monolith can emerge when microservices teams develop thick networks of dependencies. Using a retailer settings-page example, it describes how ownership boundaries, cross-team requests, context switching, and coordination delays can slow delivery and create defects. It presents the problem as both organizational and technical, with healthier boundaries as the proposed direction.

### Source excerpt

Going faster through healthier boundaries

## Why Microservices Can Increase Setup and Debugging Complexity

DevFeed: [Why Microservices Can Increase Setup and Debugging Complexity](<https://devfeed.tech/articles/give-me-back-my-monolith-41213.md>)

Original publisher: [Read original article](<https://www.craigkerstiens.com/2019/03/13/Give-me-back-my-monolith/>)

Author: Map

Published: 2019-03-13T20:55:56Z

Content type: opinion

Language: en

Sources: [Craig Kerstiens](<https://devfeed.tech/sources/craig-kerstiens.md>)

Topics: [Microservice](<https://devfeed.tech/topics/microservice.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [debugging](<https://devfeed.tech/topics/debugging.md>), [systems](<https://devfeed.tech/topics/systems.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Kubernetes](<https://devfeed.tech/topics/kubernetes.md>), [Docker](<https://devfeed.tech/topics/docker.md>)

Tags: [complexity](<https://devfeed.tech/tags/complexity.md>), [continuous-integration](<https://devfeed.tech/tags/continuous-integration.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [docker](<https://devfeed.tech/tags/docker.md>), [k8s](<https://devfeed.tech/tags/k8s.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [monolith](<https://devfeed.tech/tags/monolith.md>), [rant](<https://devfeed.tech/tags/rant.md>)

### AI overview

This opinion article argues that the move from monolithic applications to microservices can introduce substantial setup, onboarding, debugging, and testing complexity. It notes that containers and orchestration help, but distributed services can make tracing errors and maintaining compatible versions more difficult.

### Source excerpt

It feels like we're starting to pass the peak of the hype cycle of microservices. It's no longer multiple times a week we now see a blog post of "How I migrated my monolith to 150 services". Now I often hear a bit more of the counter: "I don't hate my monolith, I just care that things stay performant". We've actually seen some migrations from micro-services back to a monolith. When you go from one large application to multiple smaller services there are a number of new things you have to tackle, here is a rundown of all the things that were simple that you now get to re-visit: Setup went from intro chem to quantum mechanics Setting up a basic database and my application with a background process was a pretty defined process. I'd have the readme on Github, and often in an hour or maybe a few I'd be up and running when I started on a new project. Onboarding a new engineering, at least for an initial environment would be done in the first day. As we ventured into micro-services onboarding time skyrocketed. Yes, we have docker and orchestration such as K8s these days to help, but the time from start to up and running a K8s cluster just to onboard a new engineer is orders of magnitude larger than we saw a few years ago. For many junior engineers this is a burden that really is unnecessary complexity. So long for understanding our systems Lets stay on the junior engineer perspective for just a moment. Back when we had monolithic apps if you had an error you had a clear stacktrace to see where it originated from and could jump right in and debug. Now we have a service that talks to another service, that queues something on a message bus, that another service processes, and then we have an error. We have to piece together all of these pieces to eventually learn that service a was on version 11 and service q was expecting vesion 12 already. This in contrast to my standard consolidated log, and lets not forget my interactive terminal/debugger for when I wanted to go step by s

## Measuring production code coverage with JaCoCo

DevFeed: [Measuring production code coverage with JaCoCo](<https://devfeed.tech/articles/measuring-production-code-coverage-with-jacoco-37828.md>)

Original publisher: [Read original article](<https://carlosbecker.com/posts/production-code-coverage-jacoco/>)

Author: Carlos Alexandro Becker

Published: 2017-03-20T00:00:00Z

Content type: tutorial

Language: en

Sources: [Carlos Becker](<https://devfeed.tech/sources/carlos-becker.md>)

Topics: [test-coverage](<https://devfeed.tech/topics/test-coverage.md>), [Code](<https://devfeed.tech/topics/code.md>), [Java](<https://devfeed.tech/topics/java.md>), [Puppet](<https://devfeed.tech/topics/puppet.md>), [Maven](<https://devfeed.tech/topics/maven.md>)

Tags: [code-coverage](<https://devfeed.tech/tags/code-coverage.md>), [coverage](<https://devfeed.tech/tags/coverage.md>), [jacoco](<https://devfeed.tech/tags/jacoco.md>), [java](<https://devfeed.tech/tags/java.md>), [maven](<https://devfeed.tech/tags/maven.md>), [monolith](<https://devfeed.tech/tags/monolith.md>), [production](<https://devfeed.tech/tags/production.md>), [puppet](<https://devfeed.tech/tags/puppet.md>)

### AI overview

This tutorial explains how to use JaCoCo in a Java production environment to generate production code coverage reports. It describes instrumenting a production application server, collecting binary report files, and compiling them into HTML reports to identify code that is not executed.

### Source excerpt

Microservices is the new fancy way of doing applications. Yet, most companies still have big and old monoliths in production. In fast evolving software of this size, it's usual to have lines of code which are never executed in production. Production code coverage reports can help us find those lines.