# monolithic-architecture

Published articles for monolithic-architecture.

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

## Migrating from a Monolithic Orchestrator to Apache Airflow

DevFeed: [Migrating from a Monolithic Orchestrator to Apache Airflow](<https://devfeed.tech/articles/migrating-from-a-monolithic-orchestrator-to-apache-airflow-30518.md>)

Original publisher: [Read original article](<https://medium.com/helpshift-engineering/migrating-from-a-monolithic-orchestrator-to-apache-airflow-30fde94bcdc0?source=rss----3229f31ca4f4---4>)

Author: Poorva Patil

Published: 2026-06-03T09:20:17Z

Content type: article

Language: en

Sources: [Helpshift](<https://devfeed.tech/sources/helpshift.md>)

Topics: [airflow](<https://devfeed.tech/topics/airflow.md>), [Orchestration](<https://devfeed.tech/topics/orchestration.md>), [Clojure](<https://devfeed.tech/topics/clojure.md>), [Python](<https://devfeed.tech/topics/python.md>), [Monitoring](<https://devfeed.tech/topics/monitoring.md>)

Tags: [apache-airflow](<https://devfeed.tech/tags/apache-airflow.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [aws](<https://devfeed.tech/tags/aws.md>), [clojure](<https://devfeed.tech/tags/clojure.md>), [data-engineering](<https://devfeed.tech/tags/data-engineering.md>), [etl](<https://devfeed.tech/tags/etl.md>), [monitoring](<https://devfeed.tech/tags/monitoring.md>), [monolithic-architecture](<https://devfeed.tech/tags/monolithic-architecture.md>), [orchestration](<https://devfeed.tech/tags/orchestration.md>), [python](<https://devfeed.tech/tags/python.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>)

### AI overview

The article describes a migration from a monolithic Clojure-based scheduler to Apache Airflow. The legacy system coupled event pipelines, dependencies, and an EMR step, making workflows difficult to understand, maintain, monitor, and debug. The authors report that Airflow's Python-based DAGs made dependencies, retries, and scheduling more readable and helped improve onboarding and maintainability.

### Source excerpt

Photo by Corinne Kutz on UnsplashBefore we knew better Our orchestration system started as a simple internal solution to manage event pipelines and trigger downstream jobs. Over time, as more workflows and dependencies were added, it gradually evolved into a tightly coupled monolithic scheduler that became increasingly difficult to understand and maintain. Understanding how a workflow executed often meant looking through multiple files, configurations and database tables. For newer team members, onboarding into the system took time because much of the workflow context was distributed across different parts of the codebase. Even relatively small changes required careful coordination to ensure existing pipelines continued to work as expected. Similarly, debugging typically involved manually tracing logs and rerunning jobs to better understand execution behavior. Limitations of our legacy design We had a monolithic architecture written in Clojure that bundled all our event pipelines together, added dependencies between them and triggered a Lambda function. Legacy Workflow This Lambda function added a single monolithic step to the EMR cluster. If there was an issue in any one of the pipelines, the entire flow would fail due to the single step on the cluster. We did not have step-wise monitoring in the old design, so during on-call situations it became very difficult to identify which part of the pipeline was causing the issue. Photo by Tim Gouw on Unsplash There was no single place to answer basic questions like: What runs first? What happens if this step fails? How do I re-run just one part safely? The scheduler worked, but it was hard to understand, hard to maintain and even harder to explain. That's when we realized we needed a better way. What we actually needed Our aim was less about fancy scheduling features and more about making our daily work easier and more reliable. Simpler onboarding, less mental overhead Our existing step scheduler was built in Clojure and c

## Razorpay's Linked Payments Architecture for Combining Payment Methods

DevFeed: [Razorpay's Linked Payments Architecture for Combining Payment Methods](<https://devfeed.tech/articles/the-checkout-frustration-razorpay-fixed-combining-payment-methods-24043.md>)

Original publisher: [Read original article](<https://engineering.razorpay.com/the-checkout-frustration-razorpay-fixed-combining-payment-methods-0e0b05fdf104?source=rss----6407ad2e59af---4>)

Author: Vatsal Mehta

Published: 2026-04-08T09:56:17Z

Content type: article

Language: en

Sources: [Razorpay Engineering - Medium](<https://devfeed.tech/sources/razorpay-engineering-medium.md>)

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

Tags: [architectures](<https://devfeed.tech/tags/architectures.md>), [authorization](<https://devfeed.tech/tags/authorization.md>), [fintech](<https://devfeed.tech/tags/fintech.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [monolithic-architecture](<https://devfeed.tech/tags/monolithic-architecture.md>), [payment](<https://devfeed.tech/tags/payment.md>), [payment-gateway](<https://devfeed.tech/tags/payment-gateway.md>), [payment-processing](<https://devfeed.tech/tags/payment-processing.md>), [payments](<https://devfeed.tech/tags/payments.md>), [razorpay](<https://devfeed.tech/tags/razorpay.md>), [recovery](<https://devfeed.tech/tags/recovery.md>), [technical](<https://devfeed.tech/tags/technical.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

Razorpay describes Linked Payments, an architecture that lets customers combine a gift card with card, UPI, or another payment method for one order. The article explains the resulting challenges around authorization sequencing, failure recovery, and split settlement across payment-method microservices.

### Source excerpt

You have a $50 gift card. Your cart is $75. The checkout says "pick one payment method." This is a solvable problem. If you've ever tried to use a gift card for an online purchase, you know this frustration intimately. The gift card covers most of it, but not quite all. The checkout forces you to choose: use the gift card and abandon some items, or ignore the gift card and pay the full amount another way. Either choice feels wrong. This isn't a technical limitation of payment processing. It's an architectural one. Most payment systems treat each method as an isolated, complete transaction. You pay with a card OR UPI OR a gift card. The concept of composing multiple methods to fulfill a single order simply doesn't exist in traditional payment gateway architectures. At Razorpay, this limitation was costing merchants real money. Gift card redemption rates suffered because customers abandoned partial-value cards. Average order values stayed lower because customers couldn't combine store credit with additional payment. The business case for solving this was clear. That's why we built Linked Payments, a system that treats payment methods as composable building blocks. Customers can now use a gift card for $50, then cover the remaining $25 via card, UPI, or any other method. The system handles authorization sequencing, failure recovery, and settlement splitting automatically. The Complexity Hidden in "Just Combine Them" The challenge sounds simple until you consider what payment systems actually do. Traditional payment flows are beautifully simple. Customer initiates payment. System authorizes the full amount from one method. If authorization succeeds, capture the funds. Settle to the merchant. Either the payment worked or it didn't. One authorization, one capture, one settlement. Linked payments shatter this simplicity. Now you have multiple authorizations for a single order. Sequential dependencies where the second payment only happens if the first succeeds. Partial fail

## Modularizing SOLR Query Creation for Multi-Market Scale

DevFeed: [Modularizing SOLR Query Creation for Multi-Market Scale](<https://devfeed.tech/articles/modularizing-solr-query-creation-for-multi-market-scale-22544.md>)

Original publisher: [Read original article](<https://medium.com/walmartglobaltech/modularizing-solr-query-creation-for-multi-market-scale-a1f34e28b631?source=rss----905ea2b3d4d1---4>)

Author: Naman Parikh

Published: 2026-03-03T12:18:55Z

Content type: tutorial

Language: en

Sources: [Walmart Global Tech](<https://devfeed.tech/sources/walmart-global-tech.md>)

Topics: [Code](<https://devfeed.tech/topics/code.md>), [configuration](<https://devfeed.tech/topics/configuration.md>), [implementation](<https://devfeed.tech/topics/implementation.md>), [Testing](<https://devfeed.tech/topics/testing.md>), [debug](<https://devfeed.tech/topics/debug.md>)

Tags: [article](<https://devfeed.tech/tags/article.md>), [code](<https://devfeed.tech/tags/code.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [developer](<https://devfeed.tech/tags/developer.md>), [errors](<https://devfeed.tech/tags/errors.md>), [exceptions](<https://devfeed.tech/tags/exceptions.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [information-retrieval](<https://devfeed.tech/tags/information-retrieval.md>), [modular-monolith](<https://devfeed.tech/tags/modular-monolith.md>), [monolithic-architecture](<https://devfeed.tech/tags/monolithic-architecture.md>), [regression](<https://devfeed.tech/tags/regression.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [technical](<https://devfeed.tech/tags/technical.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

This article describes modularizing a 12,000-line SOLR query creation implementation used across multiple markets. It explains how separating query concerns, adding market-specific configuration, and using stronger typing aimed to reduce coupling, regression risk, and runtime errors.

### Source excerpt

Introduction When the SOLR query logic expanded into a 12,000-line monolithic implementation, each modification introduced significant risk, making every change feel akin to defusing a critical system. Adding a market-specific override required yet another if block, compounding complexity and slowing time-to-market. In this article, we will deep dive how we broke that SOLR query creation logic, enabling clean configuration per market, stronger typing, reducing technical debts and dramatically reduced runtime errors. Image generated with DALL-E via ChatGPTThe Problem: When SOLR Queries Creation Logic Become Technical Debt The SOLR query logic class was handling filtering logic, boosting logic, boost functions, pagination etc. All the parameters related to SOLR query was getting generated using single class. Overthe time, this core class handled various logics related to different type of queries: Primary search queries Item insertions via business tools Item insertions via semantic sources Thousands of lines tangled edge-case handling, scoring tweaks, and boosting logic. This unscalable approach: Blocked rapid iteration for new markets Tight Coupling: All query-handling logic lived in one massive class, making it difficult to cleanly separate concerns. Market-specific changes could unintentionally affect unrelated logic, requiring exhaustive regression testing. High Risk of Unintended Consequences: Changing business requirements (such as supporting different filtering or boosting strategies for a new market) entailed changing existing code that already served other markets. Developers had to be extremely cautious, as a bug or oversight could break unrelated functionality. No Configuration Flexibility: There was no clear system for externalizing market-specific configuration. Instead, all logic changes happened directly in code, preventing business users or product managers from making simple market changes without developer intervention. Increased Runtime exceptions

## Seven Software Architectural Patterns: A Plain-English Guide

DevFeed: [Seven Software Architectural Patterns: A Plain-English Guide](<https://devfeed.tech/articles/7-architectural-patterns-you-must-know-17735.md>)

Original publisher: [Read original article](<https://blog.amigoscode.com/p/7-architectural-patterns-you-must>)

Author: Nelson Djalo

Published: 2025-04-16T16:00:23Z

Content type: tutorial

Language: en

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

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

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [guide](<https://devfeed.tech/tags/guide.md>), [microservices-architecture](<https://devfeed.tech/tags/microservices-architecture.md>), [monolithic-architecture](<https://devfeed.tech/tags/monolithic-architecture.md>), [patterns](<https://devfeed.tech/tags/patterns.md>), [software-design](<https://devfeed.tech/tags/software-design.md>)

### AI overview

A plain-English guide to seven software architectural patterns: monolithic, layered, microservices, SOA, MVC, event-driven, and master-slave. It explains how these patterns organize software and discusses tradeoffs such as simplicity, scalability, complexity, and collaboration.

### Source excerpt

A simple guide to 7 software architectural patterns -- monolithic, layered, microservices, SOA, MVC, event-driven, and master-slave -- explained in plain English.

## Hetzner Cloud gets More Features to Market with Faster, More Reliable CI

DevFeed: [Hetzner Cloud gets More Features to Market with Faster, More Reliable CI](<https://devfeed.tech/articles/hetzner-cloud-gets-more-features-to-market-with-faster-more-reliable-ci-21405.md>)

Original publisher: [Read original article](<https://nx.dev/blog/hetzner-cloud-success-story>)

Author: Juri Strumpflohner

Published: 2025-02-06T00:00:00Z

Content type: article

Language: en

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

Topics: [ci](<https://devfeed.tech/topics/ci.md>), [GitLab](<https://devfeed.tech/topics/gitlab.md>), [cloud-infrastructure](<https://devfeed.tech/topics/cloud-infrastructure.md>), [Development](<https://devfeed.tech/topics/development.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [superProductivity](<https://devfeed.tech/topics/superproductivity.md>)

Tags: [ci](<https://devfeed.tech/tags/ci.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [customer-story](<https://devfeed.tech/tags/customer-story.md>), [developer-productivity](<https://devfeed.tech/tags/developer-productivity.md>), [gitlab](<https://devfeed.tech/tags/gitlab.md>), [monolithic-architecture](<https://devfeed.tech/tags/monolithic-architecture.md>), [monorepo](<https://devfeed.tech/tags/monorepo.md>), [quality](<https://devfeed.tech/tags/quality.md>)

### AI overview

This developer success story describes how Hetzner Cloud addressed team-ownership and CI-performance challenges as its codebase and projects grew. The company evaluated Nx and Turborepo, selected Nx Enterprise, and collaborated with Nx engineers on a strategy for its software landscape. Its existing pipelines took 45 minutes per run, while GitLab merge trains sometimes repeated tests and builds.

### Source excerpt

Discover how Hetzner Cloud uses Nx Enterprise to ship new features to market faster and with more reliability.

## How reliability differs between monolithic and microservice-based architectures

DevFeed: [How reliability differs between monolithic and microservice-based architectures](<https://devfeed.tech/articles/how-reliability-differs-between-monolithic-and-microservice-based-architectures-11597.md>)

Original publisher: [Read original article](<https://www.gremlin.com/blog/how-reliability-differs-between-monolithic-and-microservice-based-architectures>)

Author: Andre Newman

Published: 2024-05-14T00:00:00Z

Content type: article

Language: en

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

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

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [architectures](<https://devfeed.tech/tags/architectures.md>), [containers](<https://devfeed.tech/tags/containers.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [monolithic-architecture](<https://devfeed.tech/tags/monolithic-architecture.md>)

### AI overview

This article compares reliability in monolithic and microservice-based architectures. It explains how microservices improve independent deployment, scaling, and resource use while introducing distinct risks involving disposable servers, ephemeral applications, data persistence, and service communication.

### Source excerpt

Moving from a monolithic architecture to a microservice-based one is a massive and often failure-prone process. Learn about the reliability risks unique to microservices and how to avoid them.

## Redefining API Strategy: Why Netflix Platform Engineering Chose Federated GraphQL

DevFeed: [Redefining API Strategy: Why Netflix Platform Engineering Chose Federated GraphQL](<https://devfeed.tech/articles/redefining-api-strategy-why-netflix-platform-engineering-chose-federated-graphql-23491.md>)

Original publisher: [Read original article](<https://www.apollographql.com/blog/redefining-api-strategy-why-netflix-platform-engineering-chose-federated-graphql>)

Author: Ishwari Lokare

Published: 2024-03-13T12:37:32Z

Content type: article

Language: en

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

Topics: [GraphQL](<https://devfeed.tech/topics/graphql.md>), [Netflix](<https://devfeed.tech/topics/netflix.md>), [Platform Engineering](<https://devfeed.tech/topics/platform-engineering.md>), [API](<https://devfeed.tech/topics/api.md>), [Streaming](<https://devfeed.tech/topics/streaming.md>), [systems](<https://devfeed.tech/topics/systems.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [apollo-federation](<https://devfeed.tech/tags/apollo-federation.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [decoupling](<https://devfeed.tech/tags/decoupling.md>), [events](<https://devfeed.tech/tags/events.md>), [graphql](<https://devfeed.tech/tags/graphql.md>), [monolithic-architecture](<https://devfeed.tech/tags/monolithic-architecture.md>), [netflix](<https://devfeed.tech/tags/netflix.md>), [platform-engineering](<https://devfeed.tech/tags/platform-engineering.md>), [scale](<https://devfeed.tech/tags/scale.md>), [streaming](<https://devfeed.tech/tags/streaming.md>)

### AI overview

The article examines Netflix's 15-year evolution across five generations of APIs and its adoption of federated GraphQL. It describes how Netflix used Apollo Federation to unify APIs across platforms, decouple domain teams, and support independent API ownership while retaining an integrated Consumer Edge API.

### Source excerpt

The Netflix API evolution is a saga worth exploring, spanning 15 years and five generations of APIs, culminating in GraphQL adoption to meet the growing demands of its industry-leading streaming platform. Bruce Wang, Director of Product Platform Systems at Netflix, sat down with Matt DeBergalis, CTO at Apollo GraphQL, to discuss Netflix's extensive API journey and the adoption of GraphQL in an insightful fireside discussion during the GraphQL Summit 2023.

## A Journey from Monolith to Micro frontends at Udemy -- Part 1 of 3

DevFeed: [A Journey from Monolith to Micro frontends at Udemy -- Part 1 of 3](<https://devfeed.tech/articles/a-journey-from-monolith-to-micro-frontends-at-udemy-part-1-of-3-26357.md>)

Original publisher: [Read original article](<https://medium.com/udemy-engineering/transforming-frontend-architecture-a-journey-from-monolith-to-micro-frontends-at-udemy-part-1-e0a9c19c47bf?source=rss----19c6d3367ed4---4>)

Author: Hamza ERBAY

Published: 2024-01-02T18:47:48Z

Content type: article

Language: en

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

Topics: [Front end](<https://devfeed.tech/topics/frontend.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Scalability](<https://devfeed.tech/topics/scalability.md>), [Development](<https://devfeed.tech/topics/development.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [development](<https://devfeed.tech/tags/development.md>), [frontend](<https://devfeed.tech/tags/frontend.md>), [innovation](<https://devfeed.tech/tags/innovation.md>), [modular](<https://devfeed.tech/tags/modular.md>), [monolithic-architecture](<https://devfeed.tech/tags/monolithic-architecture.md>), [performance](<https://devfeed.tech/tags/performance.md>), [scalability](<https://devfeed.tech/tags/scalability.md>), [user-experience](<https://devfeed.tech/tags/user-experience.md>)

### AI overview

Udemy describes its migration from a monolithic frontend architecture toward micro frontends. The article explains that scaling created bottlenecks in development speed, release processes, CDN use, and user experience, motivating a more modular and scalable architecture.

### Source excerpt

Transforming Frontend Architecture: A Journey from Monolith to Micro Frontends at Udemy -- Part 1 of 3 By: Chris Nienhuis, Hamza Erbay, Matthew Bise, Nathan Chapman, Seth Hodgson, Trey Briggs, Charles Pham Photo by Annie Spratt on UnsplashIntroduction At Udemy, we have over 67M learners and over 75K instructors, and we're working on a fast and accessible experience for them. Our underlying application architecture is a monolith -- a single, unified codebase that houses our marketplace, consumer subscription services, and business applications. The engine that powers our global platform is constantly being improved by our dedicated teams working to enhance the learning and teaching experience. In the spirit of innovation, we pitched an idea at the 2021 hackathon to decouple frontend engineering from the monolithic structure. The concept resonated with the hackathon committee (Shark Tank Council), earning a decisive nod. Thus began our odyssey toward a more modular, resilient, and scalable frontend architecture. Motivation to migrate monolith to micro frontend At the heart of our decision to migrate from a monolithic architecture to micro frontends was the need to address critical pain points impeding our ability to scale and innovate effectively. Development Speed and Scalability Our monolithic application served us well in the early days, but as we scaled, it became a double-edged sword. Development speed slowed to a crawl due to two main bottlenecks: When you start a new project, the build process takes approximately 10-15 mins. Cold Start (blue and orange), Warm Start (only orange boxes)Complex Release Process Deploying our code was a difficult and time-consuming process. Any changes to the code had to go through a slow and tedious cycle of review, approval, and queuing, which often took several days, especially during release freezes. This slow process was not sustainable for a growing global team generating many experiments. The release process can take days.In 20

## What Is Apollo Federation?

DevFeed: [What Is Apollo Federation?](<https://devfeed.tech/articles/what-is-apollo-federation-23576.md>)

Original publisher: [Read original article](<https://www.apollographql.com/blog/what-is-apollo-federation>)

Author: Ceora Ford

Published: 2022-02-09T16:00:24Z

Content type: article

Language: en

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

Topics: [GraphQL](<https://devfeed.tech/topics/graphql.md>), [Development](<https://devfeed.tech/topics/development.md>)

Tags: [apollo-federation](<https://devfeed.tech/tags/apollo-federation.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [backend](<https://devfeed.tech/tags/backend.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [graphql](<https://devfeed.tech/tags/graphql.md>), [monolithic-architecture](<https://devfeed.tech/tags/monolithic-architecture.md>), [open](<https://devfeed.tech/tags/open.md>), [standard](<https://devfeed.tech/tags/standard.md>)

### AI overview

This explanatory article introduces Apollo Federation as an open-source specification and standard for building distributed GraphQL graphs. It discusses why growing graphs can become monolithic and difficult to maintain, and outlines Apollo Federation's intended benefits and starting points.

### Source excerpt

You may have heard about Apollo Federation before, especially if you're on a team that uses GraphQL and Apollo tools. But what is it exactly? Apollo Federation is an approach to application architecture created by Apollo. It's open-sourced so anyone has access. It's not a product that we offer but instead, it's a specification or a standard for building a distributed graph. It can be implemented in any language that is compatible with GraphQL. But what does that entail?

## if-else-switch

DevFeed: [if-else-switch](<https://devfeed.tech/articles/if-else-switch-21793.md>)

Original publisher: [Read original article](<http://blog.cleancoder.com/uncle-bob/2021/03/06/ifElseSwitch.html>)

Published: 2021-03-06T00:00:00Z

Content type: opinion

Language: en

Sources: [Robert C. Martin](<https://devfeed.tech/sources/robert-c-martin.md>), [The Clean Code Blog](<https://devfeed.tech/sources/the-clean-code-blog.md>)

Topics: [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [Polymorphism](<https://devfeed.tech/topics/polymorphism.md>), [Software](<https://devfeed.tech/topics/software.md>), [systems](<https://devfeed.tech/topics/systems.md>), [cloud-infrastructure](<https://devfeed.tech/topics/cloud-infrastructure.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [monolithic-architecture](<https://devfeed.tech/tags/monolithic-architecture.md>), [polymorphism](<https://devfeed.tech/tags/polymorphism.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [software](<https://devfeed.tech/tags/software.md>), [source](<https://devfeed.tech/tags/source.md>), [structure](<https://devfeed.tech/tags/structure.md>)

### AI overview

The article argues that repeated if/else or switch statements create fragile systems and tangled dependencies. It recommends isolating the conditional logic in a factory and using polymorphic objects to break dependencies on lower-level modules, supporting more flexible component-based architectures.

### Source excerpt

A few days ago someone tweeted a question asking which of the following PHP snippets was better than the others, or whether there might be an even better approach. I tweeted my answer in the following cryptic paragraph. Place the if/else cases in a factory object that creates a polymorphic object for each variant. Create the factory in 'main' and pass it into your app. That will ensure that the if/else chain occurs only once. Others have since asked me for an example. Twitter is not the best medium for that so... Firstly, if the sole intent of the programmer is to translate: 0->'male', 1->'female' otherwise -> 'unknown' ...then his refactoring #2 would be my preference. However, I have a hard time believing that the business rules of the system are not using that gender code for making policy decisions. My fear is that the if/else/switch chain that the author was asking about is replicated in many more places within the code. Some of those if/else/switch statements might switch on the integer, and others might switch on the string. It's not inconceivable that you'd find a if/else/switch that used an integer in one case and a string in the next! The proliferation of if/else/switch statements is a common problem in software systems. The fact that they are replicated in many places is problematic because when such statements are inevitably changed, it is easy to miss some. This leads to fragile systems. But there is a worse problem with if/else/switch statements. It's the dependency structure. Such statements tend to have cases that point outwards towards lower level modules. This often means that the module containing the if/else/switch will have source code dependencies upon those lower level modules. That's bad enough. We don't like dependencies that run from high level modules to low level modules. They thwart our desire to create architectures that are made up of independently deployable components. However, the above diagram shows that it's worse than that. Other hig

## Apollo Federation

DevFeed: [Apollo Federation](<https://devfeed.tech/articles/apollo-federation-23185.md>)

Original publisher: [Read original article](<https://www.apollographql.com/blog/apollo-federation-f260cf525d21>)

Author: James Baxley III

Published: 2019-05-01T22:00:00Z

Content type: release

Language: en

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

Topics: [GraphQL](<https://devfeed.tech/topics/graphql.md>), [Microservice](<https://devfeed.tech/topics/microservice.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [data](<https://devfeed.tech/topics/data.md>)

Tags: [announcement](<https://devfeed.tech/tags/announcement.md>), [apollo](<https://devfeed.tech/tags/apollo.md>), [apollo-federation](<https://devfeed.tech/tags/apollo-federation.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [declarative](<https://devfeed.tech/tags/declarative.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [graphql](<https://devfeed.tech/tags/graphql.md>), [launch](<https://devfeed.tech/tags/launch.md>), [microservice-architecture](<https://devfeed.tech/tags/microservice-architecture.md>), [monolithic-architecture](<https://devfeed.tech/tags/monolithic-architecture.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [product](<https://devfeed.tech/tags/product.md>), [schema](<https://devfeed.tech/tags/schema.md>), [services](<https://devfeed.tech/tags/services.md>)

### AI overview

Apollo introduces Apollo Federation, an open-source architecture for building a distributed GraphQL graph across microservices. It aims to replace schema stitching by letting teams declaratively compose a unified graph while owning separate portions of the schema.

### Source excerpt

What if you could access all of your organization's data by typing a single GraphQL query, even if that data lived in separate places? Up until now, this goal has been difficult to achieve without committing to a monolithic architecture or writing fragile schema stitching code. Ideally, we want to expose one graph for all of our organization's data without experiencing the pitfalls of a monolith.

## Microservices and the monolith

DevFeed: [Microservices and the monolith](<https://devfeed.tech/articles/microservices-and-the-monolith-2081.md>)

Original publisher: [Read original article](<https://developers.soundcloud.com/blog//microservices-and-the-monolith>)

Published: 2016-08-26T00:00:00Z

Content type: opinion

Language: en

Sources: [SoundCloud Backstage Blog](<https://devfeed.tech/sources/soundcloud-backstage-blog.md>)

Topics: [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Microservice](<https://devfeed.tech/topics/microservice.md>), [microservices architecture](<https://devfeed.tech/topics/microservices-architecture.md>), [HTTP](<https://devfeed.tech/topics/http.md>), [Prometheus](<https://devfeed.tech/topics/prometheus.md>), [Docker](<https://devfeed.tech/topics/docker.md>), [Kubernetes](<https://devfeed.tech/topics/kubernetes.md>), [Finagle](<https://devfeed.tech/topics/finagle.md>), [telemetry](<https://devfeed.tech/topics/telemetry.md>), [Testing](<https://devfeed.tech/topics/testing.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [docker](<https://devfeed.tech/tags/docker.md>), [finagle](<https://devfeed.tech/tags/finagle.md>), [http](<https://devfeed.tech/tags/http.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [microservices-architecture](<https://devfeed.tech/tags/microservices-architecture.md>), [monolithic-architecture](<https://devfeed.tech/tags/monolithic-architecture.md>), [prometheus](<https://devfeed.tech/tags/prometheus.md>), [telemetry](<https://devfeed.tech/tags/telemetry.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

SoundCloud reviews its migration from a monolithic architecture to microservices and evaluates the strategy needed to decommission the monolith. The article reports that internal tools and libraries improved service creation and engineering productivity, while extraction projects remained difficult because they took months and depended on multiple teams.

### Source excerpt

In a previous series of blog posts, we covered our decision to move away from a monolithic architecture, replacing it with microservices, interacting synchronously with each other over HTTP, and asynchronously using events. In this post, we review our progress toward this goal, and talk about the conditions and strategy required to decommission our monolith.