# microservices architecture

Microservices architecture is a software architecture style composed of small, autonomous, independently deployable services, each implementing a business capability and communicating through defined APIs.

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 We Refresh Razorpay's Data Warehouse 10x Faster with Graphs and Indexes

DevFeed: [How We Refresh Razorpay's Data Warehouse 10x Faster with Graphs and Indexes](<https://devfeed.tech/articles/how-we-refresh-razorpay-s-data-warehouse-10x-faster-with-graphs-and-indexes-24040.md>)

Original publisher: [Read original article](<https://engineering.razorpay.com/how-we-refresh-razorpays-data-warehouse-10x-faster-with-graphs-and-indexes-538abc244703?source=rss----6407ad2e59af---4>)

Author: Amit Prabhu

Published: 2026-07-14T14:06:16Z

Content type: article

Language: en

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

Topics: [data](<https://devfeed.tech/topics/data.md>), [airflow](<https://devfeed.tech/topics/airflow.md>), [Apache Spark](<https://devfeed.tech/topics/spark.md>), [Amazon S3](<https://devfeed.tech/topics/amazon-s3.md>), [Apache Iceberg](<https://devfeed.tech/topics/apache-iceberg.md>), [microservices architecture](<https://devfeed.tech/topics/microservices-architecture.md>), [parquet](<https://devfeed.tech/topics/parquet.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>)

Tags: [airflow](<https://devfeed.tech/tags/airflow.md>), [analytics](<https://devfeed.tech/tags/analytics.md>), [apache-iceberg](<https://devfeed.tech/tags/apache-iceberg.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [batch](<https://devfeed.tech/tags/batch.md>), [data](<https://devfeed.tech/tags/data.md>), [graphs](<https://devfeed.tech/tags/graphs.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [parquet](<https://devfeed.tech/tags/parquet.md>), [pipelines](<https://devfeed.tech/tags/pipelines.md>), [razorpay](<https://devfeed.tech/tags/razorpay.md>), [spark](<https://devfeed.tech/tags/spark.md>), [trino](<https://devfeed.tech/tags/trino.md>), [warehouse](<https://devfeed.tech/tags/warehouse.md>)

### AI overview

Razorpay describes its data warehouse refresh pipeline, which builds wide denormalized Facts by joining data from multiple microservices. The article covers the original Airflow- and Spark-based full-refresh process, the underlying lake formats and query layer, and the scaling challenges that led the team to reconsider refresh strategy, data layout, and high-cardinality dimensions.

### Source excerpt

Contributors: Utkarsh Koppikar Rohan Background Razorpay provides the payment infrastructure for millions of merchants globally. Behind every payment, settlement, and refund is a microservices architecture where each service owns its own database. While this keeps services independent and scalable, it creates a challenge for stakeholders who need to see across those boundaries. The Data Platform team manages the infrastructure that bridges this gap. Transactional data flows into the lake via CDC pipelines, ingested onto S3 in Delta Lake, Apache Iceberg, or plain Parquet formats. On top of the lake, we build domain-specific warehouse tables -- wide, pre-joined tables that co-locate all the data a consumer needs, queryable via Trino. These power two use cases: Analytics (internal dashboards on Tableau and Superset) and Reporting (merchants and regulated entities who download structured data exports; Razorpay generates nearly a million such reports per month). The warehouse tables that power both use cases are called Facts. A Fact is a flat denormalised table on S3, produced by joining 10 to 30 microservice tables and materialising the result once. A settlement Fact, for example, merges payments, refunds, adjustments, and card details into a single wide row so that a dashboard or report reads from a single table instead of joining across services in real time. It is closer to a domain-specific materialised view than a classical data warehouse fact table. We maintain over 50 such Facts, and approximately 40% of all merchant reports are served directly from them. As data volumes and the number of entities per fact grew, the batch generation pipeline began to show its limits, prompting us to rethink the refresh strategy, the data layout, and how to handle high-cardinality dimensions. The rest of this post covers that journey. The Full Refresh Pipeline: Our Baseline and the Pain The original full-refresh pipeline was straightforward. Schedule: Airflow schedules Spark jobs o

## 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

## Microservices Deep Dive: Architecting for Scalability and Resilience

DevFeed: [Microservices Deep Dive: Architecting for Scalability and Resilience](<https://devfeed.tech/articles/microservices-deep-dive-architecting-for-scalability-and-resilience-39562.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/10-microservices-architecture/>)

Author: hello@ankit-rana.com

Published: 2026-03-16T00:00:00Z

Content type: tutorial

Language: en

Sources: [Ankit Rana | Mechanical Sympathy](<https://devfeed.tech/sources/ankit-rana-mechanical-sympathy.md>)

Topics: [microservices architecture](<https://devfeed.tech/topics/microservices-architecture.md>), [Scalability](<https://devfeed.tech/topics/scalability.md>), [Resilience](<https://devfeed.tech/topics/resilience.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Domain-driven design (DDD)](<https://devfeed.tech/topics/domain-driven-design.md>), [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>), [Deployment](<https://devfeed.tech/topics/deployment.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [ci-cd](<https://devfeed.tech/tags/ci-cd.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [deployments](<https://devfeed.tech/tags/deployments.md>), [devops](<https://devfeed.tech/tags/devops.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [domain-driven-design-ddd](<https://devfeed.tech/tags/domain-driven-design-ddd.md>), [incident-response](<https://devfeed.tech/tags/incident-response.md>), [independent](<https://devfeed.tech/tags/independent.md>), [isolation](<https://devfeed.tech/tags/isolation.md>), [layer](<https://devfeed.tech/tags/layer.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [observability](<https://devfeed.tech/tags/observability.md>), [resilience](<https://devfeed.tech/tags/resilience.md>), [scalability](<https://devfeed.tech/tags/scalability.md>), [services](<https://devfeed.tech/tags/services.md>), [system-design](<https://devfeed.tech/tags/system-design.md>)

### AI overview

This article explains how microservices replace a tightly coupled monolith with independently deployable services aligned to business capabilities. It covers benefits such as independent scaling, fault isolation, team autonomy, and technology flexibility, while noting the added costs of communication, observability, operations, and data management. It recommends using microservices when domain complexity and scale justify the operational cost, organizing services around bounded contexts, and extracting one domain at a time.

### Source excerpt

Microservices trade deployment simplicity for independent scaling, fault isolation, and team autonomy, and they only pay off once domain complexity and scale justify the operational cost. Align services to bounded contexts, give each its own data store, and extract one domain at a time rather than splitting by technical layer.

## Order Dispatch Systems at Scale

DevFeed: [Order Dispatch Systems at Scale](<https://devfeed.tech/articles/order-dispatch-systems-at-scale-30799.md>)

Original publisher: [Read original article](<https://devblog.kogan.com/blog/order-dispatch-systems-at-scale>)

Author: Guest User

Published: 2025-07-28T01:53:56Z

Content type: tutorial

Language: en

Sources: [Kogan.com](<https://devfeed.tech/sources/kogan-com.md>)

Topics: [Amazon Simple Queue Service (SQS)](<https://devfeed.tech/topics/amazon-simple-queue-service-sqs.md>), [event driven](<https://devfeed.tech/topics/event-driven.md>), [Scalability](<https://devfeed.tech/topics/scalability.md>), [Amazon Web Services](<https://devfeed.tech/topics/aws.md>), [Microservices](<https://devfeed.tech/topics/microservices.md>), [microservices architecture](<https://devfeed.tech/topics/microservices-architecture.md>), [Latency](<https://devfeed.tech/topics/latency.md>)

Tags: [aws](<https://devfeed.tech/tags/aws.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [event](<https://devfeed.tech/tags/event.md>), [event-driven](<https://devfeed.tech/tags/event-driven.md>), [latency](<https://devfeed.tech/tags/latency.md>), [microservices-architecture](<https://devfeed.tech/tags/microservices-architecture.md>), [scale](<https://devfeed.tech/tags/scale.md>), [sqs](<https://devfeed.tech/tags/sqs.md>)

### AI overview

This tutorial compares vertical and horizontal scaling, pull-based queues using AWS Simple Queue Service, and event-driven architecture for order dispatch systems. It describes queue trade-offs and explains how event subscribers can process orders independently and scale separately.

### Source excerpt

How to load-balance like a seasoned waiter Software systems often parallel the real world. Imagine running a busy restaurant, where customers line up to make orders whilst the kitchen prepares the meals. In the software world, your users are the customers, and your backend services are the kitchen. With more people online than ever before, that line might start to grow out the front door. The ability to scale is no longer optional, it is essential. Know Your Options Vertical Scaling - Scale Up Horizontal Scaling - Scale Out Expanding your restaurant by adding more tables or a larger kitchen. In software terms, this means scaling up your infrastructure. More powerful CPUs, larger memory, increased throughput etc. This is a relative quick fix, but comes with diminishing returns and limits on how big everything can get. Opening new restaurant locations to serve more customers simultaneously and distribute existing flows. In software terms, this means adding more API servers, more worker nodes or creating many database replicas. This approach is more flexible and scalable than vertical scaling in the long term. A Steppingstone - Queues Just like how customers queue for their order, we create a pull-based task queue for our order management system using AWS Simple Queue Service (SQS). Tasks get queued into the SQS, and a consumer service will continuously poll this queue to process the tasks. This gives a lot of control for the queue consumer to dictate the frequency of polling, which works well in systems that cannot handle high throughput or requires non-concurrency like the SAP ERP (more on that later). SQS also provides built-in dead-letter-queues, retry policies, at least once delivery guarantee and scales automatically. Vertical scaling involves sizing up the compute power of the consumer (CPU, RAM etc). Horizontal scaling involves spinning up more consumers of the SQS. However, queues have limitations: Latency between order arrival and processing. Inefficient poll

## Microauthorization: Why Microservices can be Great for Security Hygiene

DevFeed: [Microauthorization: Why Microservices can be Great for Security Hygiene](<https://devfeed.tech/articles/microauthorization-why-microservices-can-be-great-for-security-hygiene-13156.md>)

Original publisher: [Read original article](<https://www.chainguard.dev/unchained/microauthorization-why-microservices-can-be-great-for-security-hygiene>)

Published: 2025-05-08T00:00:00Z

Content type: opinion

Language: en

Sources: [Chainguard: Unchained](<https://devfeed.tech/sources/chainguard-unchained.md>)

Topics: [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [microservices architecture](<https://devfeed.tech/topics/microservices-architecture.md>), [Security](<https://devfeed.tech/topics/security.md>), [Authorization](<https://devfeed.tech/topics/authorization.md>), [IAM](<https://devfeed.tech/topics/iam.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [authorization](<https://devfeed.tech/tags/authorization.md>), [container-security](<https://devfeed.tech/tags/container-security.md>), [iam](<https://devfeed.tech/tags/iam.md>), [least-privilege](<https://devfeed.tech/tags/least-privilege.md>), [microauthorization](<https://devfeed.tech/tags/microauthorization.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [remote-code-execution](<https://devfeed.tech/tags/remote-code-execution.md>), [security](<https://devfeed.tech/tags/security.md>)

### AI overview

The article argues that decomposing monolithic applications into microservices can improve security hygiene by isolating processes and assigning each service a distinct identity with narrower IAM capabilities. It explains that service-to-service authorization can limit the blast radius of a breach, although attackers may still need to move laterally across services.

### Source excerpt

Microservices can enable you to easily independently roll out services, but they can also provide security benefits. Learn more with Chainguard CTO Matt Moore.

## Architectural Design for a Ride App such as OLA, UBER, RAPIDO

DevFeed: [Architectural Design for a Ride App such as OLA, UBER, RAPIDO](<https://devfeed.tech/articles/architectural-design-for-a-ride-app-such-as-ola-uber-rapido-33335.md>)

Original publisher: [Read original article](<https://blog.ratnesh-maurya.com/blog/Architectural-Design-for-a-Ride-App-such-as-OLA-UBER-RAPIDO>)

Author: ratneshmaurya2311@gmail.com (Ratnesh Maurya)

Published: 2024-07-30T00:00:00Z

Content type: article

Language: en

Sources: [Ratn Labs](<https://devfeed.tech/sources/ratn-labs.md>)

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

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [backend](<https://devfeed.tech/tags/backend.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [microservices-architecture](<https://devfeed.tech/tags/microservices-architecture.md>), [queues](<https://devfeed.tech/tags/queues.md>), [rest](<https://devfeed.tech/tags/rest.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [system-design](<https://devfeed.tech/tags/system-design.md>), [system-design-backend](<https://devfeed.tech/tags/system-design-backend.md>), [tracking](<https://devfeed.tech/tags/tracking.md>), [vs](<https://devfeed.tech/tags/vs.md>)

### AI overview

An overview of architectural design for a ride-sharing app, covering microservice boundaries, REST, gRPC, message queues, geolocation tracking, and the trade-offs between starting with a monolith and adopting microservices.

### Source excerpt

Microservices architecture for ride-sharing: service boundaries, REST vs gRPC vs message queues, geo-location tracking, and trade-offs between monolith-first and microservices.

## 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

## Schema Services: Transitioning Towards a Federated Architecture

DevFeed: [Schema Services: Transitioning Towards a Federated Architecture](<https://devfeed.tech/articles/schema-services-transitioning-towards-a-federated-architecture-23505.md>)

Original publisher: [Read original article](<https://www.apollographql.com/blog/schema-services-transitioning-towards-a-federated-graphql-architecture>)

Author: Andy Roberts

Published: 2020-11-04T15:09:30Z

Content type: tutorial

Language: en

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

Topics: [GraphQL](<https://devfeed.tech/topics/graphql.md>), [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: [apollo-federation](<https://devfeed.tech/tags/apollo-federation.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [backend](<https://devfeed.tech/tags/backend.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [graphql](<https://devfeed.tech/tags/graphql.md>), [microservices-architecture](<https://devfeed.tech/tags/microservices-architecture.md>), [rest](<https://devfeed.tech/tags/rest.md>), [services](<https://devfeed.tech/tags/services.md>)

### AI overview

This article introduces schema services as a transitionary architecture for organizations moving toward a federated GraphQL architecture. It discusses how schema services can help bridge legacy and modern services, mixed protocols, data-centric APIs, and GraphQL skills gaps during an Apollo Federation adoption.

### Source excerpt

The reality for most large organizations adopting Federation is that the architecture sitting behind it is... messy. In this article, I will introduce the concept of schema services and demonstrate how they can provide an easier transition towards a federated architecture. From a jumble of modern and legacy services, different tech stacks, data sources, platforms, etc. most enterprise architecture diagrams look more like a grab bag of tech from the last couple of decades than anything else.

## The Road to an Envoy Service Mesh

DevFeed: [The Road to an Envoy Service Mesh](<https://devfeed.tech/articles/the-road-to-an-envoy-service-mesh-27020.md>)

Original publisher: [Read original article](<https://medium.com/square-corner-blog/the-road-to-an-envoy-service-mesh-d1a51cbd31dd?source=rss----3650599ae4e2---4>)

Author: Snow Pettersen

Published: 2019-03-29T15:36:51Z

Content type: article

Language: en

Sources: [Square Corner Blog - Medium](<https://devfeed.tech/sources/square-corner-blog-medium.md>)

Topics: [microservices architecture](<https://devfeed.tech/topics/microservices-architecture.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [interoperability](<https://devfeed.tech/topics/interoperability.md>), [Remote Procedure Call (RPC)](<https://devfeed.tech/topics/rpc.md>), [Go Language](<https://devfeed.tech/topics/go-language.md>), [Java](<https://devfeed.tech/topics/java.md>), [Ruby](<https://devfeed.tech/topics/ruby.md>), [Ruby on Rails](<https://devfeed.tech/topics/ruby-on-rails.md>), [gRPC](<https://devfeed.tech/topics/grpc.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [automatic](<https://devfeed.tech/tags/automatic.md>), [discovery](<https://devfeed.tech/tags/discovery.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [envoy-proxy](<https://devfeed.tech/tags/envoy-proxy.md>), [failover](<https://devfeed.tech/tags/failover.md>), [go](<https://devfeed.tech/tags/go.md>), [http](<https://devfeed.tech/tags/http.md>), [interoperability](<https://devfeed.tech/tags/interoperability.md>), [java](<https://devfeed.tech/tags/java.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [microservices-architecture](<https://devfeed.tech/tags/microservices-architecture.md>), [routing](<https://devfeed.tech/tags/routing.md>), [rpc](<https://devfeed.tech/tags/rpc.md>), [ruby](<https://devfeed.tech/tags/ruby.md>), [service-mesh](<https://devfeed.tech/tags/service-mesh.md>)

### AI overview

Square describes its evolution from a Ruby on Rails monolith to a microservices architecture and explains the interoperability challenges created by its Java, Ruby, and Go stack. The article outlines its Protobuf-based Sake RPC framework, its routing, failover, traffic-shaping, and service-discovery features, and Square's migration toward a full service mesh.

### Source excerpt

Heads up, we've moved! If you'd like to continue keeping up with the latest technical content from Square please visit us at our new home https://developer.squareup.com/blog At Square we've been running a microservices architecture for years, primarily using three different languages: Java, Ruby and Go. Running such a diverse stack can make interoperability between the different languages/frameworks challenging, and in this post I'll talk about how Square has handled this in the past and where we're at today -- actively migrating towards a full service mesh. The Old World Square started off, like many other companies, just running one large monolith. For Square this was a big Ruby on Rails service, that handled everything that Square did. A monolith makes service to service communication completely unnecessary: everything runs in the same code base on a single database, so everything can be implemented without making any outbound network calls (except to third parties outside of Square). After a while, Square decided to move more towards a service oriented architecture to reduce the reliance on a single, large application. To do this Square decided to build their own Protobuf based RPC framework, inspired by Google's Stubby. This was years before gRPC was created, so there weren't any open source options at the time. This RPC framework, called Sake, was implemented for Java and Go as these were the languages used for higher availability services, while regular REST HTTP was used between services that didn't understand Sake. (Incidentally, Sake became a part of gRPC's DNA) Over time this framework became fairly sophisticated, with many features not generally available: Smart retries with automatic failover Prioritized routing based on upstream health Traffic shaping and service discovery This ended up working well, but relied on fat client/server libraries, so extending support to other languages was hard. Attempts were made to bring feature parity between languages i

## 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.

## Finn.no's architecture summit focused on breaking up its iAD monolith into microservices

DevFeed: [Finn.no's architecture summit focused on breaking up its iAD monolith into microservices](<https://devfeed.tech/articles/finn-no-wanted-to-split-up-their-monolith-you-won-t-believe-what-happens-next-31989.md>)

Original publisher: [Read original article](<https://tech.finn.no2015/02/10/summit/>)

Author: Audun Fauchald Strand

Published: 2015-02-10T11:00:00Z

Content type: article

Language: en

Sources: [Finn.no](<https://devfeed.tech/sources/finn-no.md>)

Topics: [microservices architecture](<https://devfeed.tech/topics/microservices-architecture.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Domain-driven design (DDD)](<https://devfeed.tech/topics/domain-driven-design.md>), [event driven](<https://devfeed.tech/topics/event-driven.md>), [Node.js](<https://devfeed.tech/topics/node-js.md>), [RxJava](<https://devfeed.tech/topics/rxjava.md>), [reactive](<https://devfeed.tech/topics/reactive.md>), [real-time](<https://devfeed.tech/topics/real-time.md>), [legacy](<https://devfeed.tech/topics/legacy.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [architectures](<https://devfeed.tech/tags/architectures.md>), [development](<https://devfeed.tech/tags/development.md>), [domain-driven-design](<https://devfeed.tech/tags/domain-driven-design.md>), [event-driven](<https://devfeed.tech/tags/event-driven.md>), [legacy](<https://devfeed.tech/tags/legacy.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [microservices-architecture](<https://devfeed.tech/tags/microservices-architecture.md>), [node-js](<https://devfeed.tech/tags/node-js.md>), [reactive](<https://devfeed.tech/tags/reactive.md>), [real-time](<https://devfeed.tech/tags/real-time.md>), [rxjava](<https://devfeed.tech/tags/rxjava.md>)

### AI overview

Finn.no organized a two-day architecture summit to coordinate its development teams around a microservices architecture after breaking up the iAD monolith. The program covered domain-driven design, event-driven architecture, CQRS, service properties, and implementation examples using Node.js, RxJava, and Reactive Streams.

### Source excerpt

After working several years with (successfully) breaking up the legacy monolith, called iAD, Finn.no wanted to add structure to this process, and make sure that all 20 development teams work towards the same target. The target is a microservices architecture with small-ish autonomous services, owning their own data. With that in mind we arranged our own two-day architecture summit for all Lead Developers, with a combination of external and internal presenters. The focus was on microservices, domain driven design, event driven architectures and modern programming techniques. We started off the first day with a long session. Finn.no's Chief Enterprise Architect Sebastian Verheughe wanted to communicate his vision. This included topics such as strategic domain-driven-design, data-highways, and how to use event-driven architecture to further decouple our services. This theme continued, with the first external presenter. Jan Ove Skogheim from Particular Software talked about his experiences from Rikstoto, and how they had broken up a monolith into multiple small services. He also talked about the composite-UI pattern. After lunch we continued with a presentation by Karsten Mevassvik from finn.no, of the most important properties for a finn.no microservice. These include: Is RESTful Owns its own data-store Team ownership Consumer Driven The first day of the summit was concluded with a presentation of the CQRS architectural pattern. This presentation was held by Idar Borlaug and Andreas Berre from WebStep. They showed all the central concepts in CQRS, such as commands, event-stores, aggregates, sagas using very good examples to illustrate their concepts. The second day of the summit started off with some hardcore programming. The frameworks of choice was node.js and RxJava. Christopher Kolstad started with an example of how a microservice could be implemented using Reactive Streams and RxJava. After that Phillip Johnsen presented a case using node.js in a real time context