Best of Microservices — June 2025

1. 1
   Article

   ByteByteGo·46w

   Shopify Tech Stack

   Shopify processes massive scale with 173 billion requests on Black Friday using a tech stack built on Ruby on Rails, React, MySQL, and Kafka. The platform uses a modular monolith architecture with strict component boundaries, database sharding through isolated pods, and extensive tooling investments including YJIT compiler and Sorbet type checker. The infrastructure handles 284 million requests per minute at peak, 66 million Kafka messages per second, and processes 216 million ML embeddings daily for semantic search, all while maintaining developer productivity through comprehensive CI/CD pipelines and observability tools.

   385

   9
2. 2
   Video

   ByteByteGo·44w

   7 System Design Concepts Explained in 10 Minutes

   Seven fundamental concepts power reliable distributed systems: CAP theorem forces choosing between consistency and availability during network partitions, eventual consistency enables high performance through delayed convergence, load balancers distribute traffic using Layer 4 or Layer 7 strategies, consistent hashing minimizes data movement when scaling nodes, circuit breakers prevent cascade failures by blocking requests to failing services, rate limiting protects against overload using token bucket or sliding window algorithms, and monitoring provides visibility through metrics, logs, traces, and events to maintain system health.

   195

   3
3. 3
   Article

   Three Dots Labs·46w

   Event Driven Architecture: The Hard Parts

   Event-driven architecture offers powerful benefits like scaling and decoupling but comes with significant challenges. Key issues include debugging async systems without proper observability, handling eventual consistency, preventing message loss through the outbox pattern, and designing events that avoid tight coupling. The architecture requires idempotent handlers to manage duplicate message delivery, proper dead letter queue handling, and careful consideration of message ordering. While EDA can solve real problems, it adds complexity that isn't always justified - sometimes synchronous systems or monoliths are better choices.

   174

   1
4. 4
   Article

   Devtron·46w

   CI/CD Best Practices for Microservice Architecture

   Traditional CI/CD pipelines fail to scale with microservices architecture. Each microservice requires isolated pipelines with independent versioning, progressive deployment strategies like canary and blue/green deployments, proper access controls, and comprehensive observability. Key principles include service-level pipeline isolation, semantic versioning, GitOps workflows, role-based access control, standardized templates, security scanning, and tracking DORA metrics. Platforms like Devtron help teams achieve 40% MTTR reduction, 3x deployment frequency increase, and faster service onboarding through Kubernetes-native CI/CD automation.

   160

   1
5. 5
   Article

   Awesome Go·45w

   Modern (Go) application design

   Explores modern Go application design principles emphasizing structure and composability. Discusses two key approaches: use case-driven structure (like CLI tools) and data model-first principles using repository patterns with generics. Demonstrates how to separate concerns through layered architecture with storage, business, and view layers. Shows practical examples of implementing CRUD operations, aggregates, and the MVC pattern while maintaining clean boundaries between components for better testability and maintainability.

   148

   2
6. 6
   Article

   Medium·45w

   How Kafka Saved Our Payment System And Helped Us Scale to 10 Million Users

   A payment system was failing due to synchronous processing of multiple tasks (email, notifications, logging) in a single thread, causing delays and duplicate charges. The team implemented Kafka as a message broker to decouple services through event-driven architecture. After a payment succeeds, the system publishes a single event to Kafka, allowing independent services to consume and process it asynchronously. This approach eliminated blocking operations, improved response times, reduced support tickets, and enabled the system to scale to 10 million users while maintaining reliability and making it easier to add new features.

   144

   5
7. 7
   Article

   Medium·43w

   Why We Replaced Kafka with gRPC for Service Communication

   A development team replaced Kafka with gRPC for synchronous service communication in their loan servicing platform after experiencing issues with debugging, latency, and operational complexity. While keeping Kafka for appropriate use cases like audit logs and fan-out patterns, they found gRPC provided better performance (70-80% latency reduction), easier debugging, and simpler infrastructure management for request-response interactions. The key lesson was using each tool for its intended purpose rather than forcing one solution everywhere.

   135

   7
8. 8
   Article

   ByteByteGo·47w

   How Netflix Runs on Java?

   Netflix operates its massive streaming platform primarily on Java, utilizing a federated GraphQL architecture with Spring Boot microservices. The company migrated from Java 8 to JDK 21+, adopting virtual threads for improved concurrency and ZGC garbage collector for near-zero pause times. Their backend consists of around 3000 Spring Boot services communicating via gRPC, with GraphQL serving as the client-facing API layer. Netflix moved away from reactive programming (RxJava) in favor of virtual threads and structured concurrency, while building custom tooling to maintain their Spring Boot Netflix stack with company-specific integrations for security, observability, and service mesh functionality.

   124

   1
9. 9
   Article

   Last9·44w

   11 Best Log Monitoring Tools for Developers in 2025

   A comprehensive comparison of 11 log monitoring tools for developers in 2025, covering solutions from simple centralized logging (Papertrail) to enterprise-scale platforms (Datadog, Dynatrace). The guide evaluates each tool's strengths, limitations, pricing, and ideal use cases, while providing practical advice on choosing the right solution based on team size, log volume, and technical requirements. Key tools covered include Last9, Better Stack, Grafana Loki, Elastic Stack, and others, with emphasis on real-world implementation considerations like structured logging, query performance, and cost optimization.

   120

   3
10. 10
    Video

    Community Picks·44w

    Learn Microservices and Kafka with an E-commerce Example | Kafka Tutorial for beginners

    A comprehensive tutorial demonstrating how to transform a monolithic e-commerce application into a microservices architecture using Apache Kafka for inter-service communication. The guide covers breaking down payment, order, email, and analytics services into independent components, implementing Kafka producers and consumers, setting up Docker containers, and creating fault-tolerant Kafka clusters with multiple brokers and partitions. The tutorial includes practical code examples showing how to handle asynchronous messaging, reduce response times from 12 seconds to 3 seconds, and ensure system resilience through distributed architecture.

    101
11. 11
    Article

    InfluxData·43w

    Microservices to Monolith, Rebuilding Our Backend in Rust

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

    90

    4
12. 12
    Article

    WunderGraph·47w

    We accidentally built a backend framework for LLMs

    WunderGraph accidentally created a backend framework for LLMs while solving API orchestration challenges. Their Cosmo Plugins system uses LLMs to generate proxy code that connects non-GraphQL services to a unified Supergraph, enabling companies to build modular monoliths or microservices without rewriting existing REST APIs. The framework leverages GraphQL Federation to create a single API entry point from multiple services, reducing complexity and API calls while maintaining deployment flexibility.

    78

    1
13. 13
    Article

    Nordic APIs·46w

    Top 10 API Gateways in 2025

    A comprehensive comparison of 10 leading API gateways in 2025, including Kong Gateway, Zuplo, Tyk, Gravitee, MuleSoft, Axway, Sensedia, Azure APIM, WSO2, and IBM API Connect. Each solution is evaluated based on core features, use cases, and target audiences, with considerations for deployment models, protocol requirements, ecosystem integration, and compliance needs. The guide emphasizes that API gateways have evolved beyond simple routing to become control planes for security, observability, and developer experience.

    77
14. 14
    Article

    Netguru·43w

    Golang vs C#: Backend Battle - What Top Companies Choose

    Go and C# represent different philosophies for backend development. Go offers superior memory efficiency (25MB vs 162MB), faster initial response times, and simpler deployment with 6MB container images. C# provides a mature ecosystem, comprehensive tooling, and better enterprise integration. Go excels in microservices and cloud-native applications, while C# dominates desktop applications and enterprise systems. Performance differences narrow under sustained load, with both languages suitable for production workloads. The choice depends on team expertise, infrastructure, and specific project requirements rather than absolute performance metrics.

    74

    5
15. 15
    Article

    The New Stack·47w

    Why 90% of Microservices Still Ship Like Monoliths

    Most organizations with microservice architectures still use monolithic release processes, batching changes together for testing and deployment. This approach negates the core benefits of microservices like independent deployments and team autonomy. The main culprits are expensive integration tests and limited shared environments. Sandbox environments offer a solution by enabling individual change testing against real dependencies without full infrastructure duplication, dramatically reducing deployment time from days to hours while improving code quality and developer productivity.

    52

    2
16. 16
    Article

    freeCodeCamp·44w

    Kubernetes Networking Tutorial: A Guide for Developers

    Kubernetes networking enables containerized workloads to communicate through a flat network model where each pod gets a unique IP address without NAT. The tutorial covers core concepts including CNI plugins (Flannel, Calico, Cilium), kube-proxy for service load balancing, CoreDNS for service discovery, and network policies for security. It explains pod-to-pod, pod-to-service, and external-to-service communication patterns, along with practical troubleshooting techniques for common networking issues like unreachable pods and services.

    44
17. 17
    Article

    freeCodeCamp·46w

    OpenFeign vs WebClient: How to Choose a REST Client for Your Spring Boot Project

    OpenFeign and WebClient are two popular REST client options for Spring Boot applications. OpenFeign offers a declarative approach using annotated interfaces, integrates seamlessly with Spring Cloud components, and works well for synchronous microservice communication. WebClient provides a reactive, non-blocking HTTP client with fluent API design, better suited for high-throughput applications and reactive programming models. The choice depends on your architecture: use OpenFeign for traditional Spring Cloud microservices prioritizing simplicity, and WebClient for reactive applications requiring high performance and concurrent request handling.

    35
18. 18
    Article

    System Design Codex·47w

    How to Improve Scalability?

    Scalability is the ability to handle increasing workloads through cost-effective strategies, not just adding more infrastructure. Common bottlenecks include centralized components, high-latency operations, and tight coupling between services. Key principles for scalable systems are statelessness, loose coupling, and asynchronous processing. Essential techniques include load balancing with tools like NGINX and HAProxy, caching with Redis and CDNs, event-driven processing using Kafka and RabbitMQ, and database sharding to distribute data across multiple servers. True scalability balances performance improvements with cost efficiency, requiring architectural mindset from the beginning of system design.

    28

    1
19. 19
    Article

    Medium·43w

    1 Lakh Users. 20K Requests/sec. CQRS & SAGA Patterns Saved Our LMS

    A fintech team faced system failures when their loan management system couldn't handle partial failures during loan rescheduling operations. The monolithic approach caused data inconsistencies when services failed mid-process. They solved this by implementing CQRS to separate read and write operations, and SAGA pattern to manage distributed transactions with automatic rollback capabilities. The solution transformed their system from handling 1 lakh users with frequent failures to processing 20K requests per second reliably.

    27
20. 20
    Article

    Codemotion·44w

    How Netflix Scales to 270 Million Users with Java and Microservices

    Netflix serves 270 million users through a sophisticated microservices architecture built primarily with Java. The platform splits operations between a control plane on AWS handling user interactions and recommendations, and a proprietary CDN called Open Connect with 17,000+ servers worldwide for content delivery. Key innovations include circuit breaker patterns with Hystrix, service discovery with Eureka, reactive programming with RxJava, and chaos engineering practices. The architecture employs polyglot persistence across multiple databases, extensive observability with petabytes of telemetry data, and hundreds of machine learning models for personalized recommendations.

    23

    1
21. 21
    Article

    Baeldung·44w

    Introduction to Ambassador Design Pattern

    The Ambassador Design Pattern acts as a network proxy between clients and servers, encapsulating networking components like retry logic, caching, timeouts, and circuit breakers in a reusable component. It can be implemented as a library dependency within the same container or as a separate sidecar container exposing REST APIs. The pattern promotes code reusability and maintainability by centralizing network communication logic, but introduces potential latency and availability concerns when deployed as a separate service.

    21
22. 22
    Article

    Telerik·44w

    .NET Aspire 1: What Is .NET Aspire?

    .NET Aspire is an opinionated toolkit designed to simplify cloud-native development by providing building blocks that handle common complexities like service discovery, health checks, telemetry, and secret management. The author introduces it as a solution to reduce the cognitive load of managing distributed microservices while maintaining the benefits of cloud-native architecture. The post sets up a five-part series that will demonstrate applying .NET Aspire to transform a monolithic guitar shop application into a microservices architecture.

    18
23. 23
    Video

    bigboxSWE·46w

    Programming Trends We Forgot

    A retrospective look at programming technologies that were once popular but have fallen out of favor, including Ruby on Rails, microservices, jQuery, Flash, Java applets, LAMP stack, CoffeeScript, GraphQL, and various development practices. The piece explores why these technologies lost their hype despite many still being functional and useful, often due to newer alternatives, changing developer preferences, or the rapid pace of technological evolution in software development.

    14

    7
24. 24
    Video

    Awesome·46w

    A way better alternative to microservices... Self-contained systems explained

    Self-contained systems (SCS) offer a middle ground between monolithic and microservices architectures by creating independent vertical slices that include their own UI, backend logic, and database without runtime dependencies. Unlike microservices that often create distributed complexity for systems that don't need it, SCS maintains simplicity while providing modularity through business-aligned boundaries. Communication between systems is minimized and handled through UI links or asynchronous messaging. This approach eliminates common microservices problems like circuit breakers, distributed tracing, and complex DevOps while avoiding the monolithic frontend antipattern.

    12
25. 25
    Article

    ByteByteGo·46w

    How Lyft Uses ML to Make 100 Million Predictions A Day

    Lyft processes 100 million ML predictions daily through their LyftLearn Serving platform, which addresses both data plane performance and control plane complexity. The system uses isolated microservices where each team owns their repository, deployment pipeline, and runtime environment. Key components include an HTTP serving layer with Flask/Gunicorn, a core serving library handling model lifecycle, custom ML code injection points, and integration with Kubernetes/Envoy infrastructure. The platform features automated config generation, built-in model self-testing, and supports any Python-compatible ML framework while maintaining strict isolation between teams.

    12