Best of Distributed Systems — July 2025

  1. 1
    Article
    Avatar of systemdesigncodexSystem Design Codex·44w

    Must-Know Event-Driven Architectural Patterns

    Seven essential event-driven architectural patterns are explored: Competing Consumer for scaling workloads, Asynchronous Task Execution for decoupled processing, Consume and Project for read-optimized views, Saga for distributed transactions, Event Aggregation for combining events, Event Sourcing for complete audit trails, and Transactional Outbox for atomic database and event operations. Each pattern addresses specific challenges in building resilient, scalable event-driven systems with practical examples and implementation considerations.

  2. 2
    Article
    Avatar of netflixNetflix TechBlog·45w

    Netflix Tudum Architecture: from CQRS with Kafka to CQRS with RAW Hollow

    Netflix migrated their Tudum fan site architecture from a CQRS pattern using Kafka and traditional caching to RAW Hollow, an in-memory compressed object database. The original architecture suffered from eventual consistency delays, taking minutes for content changes to appear. RAW Hollow eliminated the need for separate databases and Kafka infrastructure by storing the entire dataset in memory across application processes, reducing homepage construction time from 1.4 seconds to 0.4 seconds and enabling real-time content previews.

  3. 3
    Article
    Avatar of threedotslabsThree Dots Labs·46w

    AMA #1: Clean Architecture, Learning, Event-Driven, Go

    Three Dots Labs hosts their first AMA episode covering Go's advantages in AI development, clean architecture implementation strategies, career transitions in tech, and distributed system timeout handling. Key insights include Go's superior concurrency for AI orchestration, the importance of adding architectural complexity only when needed, internal career transitions being easier than external ones, and considering asynchronous communication to solve synchronous timeout issues in service chains.

  4. 4
    Article
    Avatar of hnHacker News·42w

    jarulraj/periodic-table: A Periodic Table of System Design Principles

    A comprehensive taxonomy of 40+ system design principles organized into 8 thematic groups covering structure, efficiency, semantics, distribution, planning, operability, reliability, and security. The framework provides a shared vocabulary for understanding recurring patterns across computer systems domains like databases, operating systems, and distributed systems, helping students recognize connections between seemingly disparate areas and enabling practitioners to communicate design trade-offs more clearly.

  5. 5
    Article
    Avatar of architectureweeklyArchitecture Weekly·46w

    Dealing with Eventual Consistency, and Causal Consistency using Predictable Identifiers

    Explores how predictable identifiers (URNs) can solve eventual consistency challenges in file upload systems. Demonstrates using pre-signed URLs for direct client-to-storage uploads, implementing the 'magic folder' pattern for file organization, and maintaining system functionality during temporary inconsistency periods. Shows practical implementation of eventual vs causal consistency concepts through a construction documentation system example.

  6. 6
    Article
    Avatar of architectureweeklyArchitecture Weekly·43w

    Workflow Engine design proposal, tell me your thoughts

    A design proposal for a workflow engine built on event sourcing principles that provides durable execution for multi-step business processes. The engine uses event streams as both inbox and outbox for workflow instances, enabling natural recovery, observability, and testing. Unlike complex tools like Temporal, it follows familiar patterns with decide/evolve functions, making simple workflows easy to write while keeping advanced features available when needed.

  7. 7
    Article
    Avatar of hnHacker News·47w

    People Keep Inventing Prolly Trees

    Prolly trees, a data structure combining Merkle trees with content-defined chunking, have been independently invented at least four times since 2009 under different names. Starting with bup in 2009, then Noms in 2015 (coining "prolly tree"), French researchers in 2019 ("Merkle Search Trees"), and DePaul University in 2020 ("Content-Defined Merkle Trees"). These structures provide history independence, efficient diffing, structural sharing, and self-balancing properties, making them valuable for version control systems and distributed applications. The repeated independent discovery suggests strong demand for this technology in modern software development.

  8. 8
    Article
    Avatar of kodekloudKodeKloud's Squad·45w

    MCP (Model Context Protocol) Simplified – But Let's Go Deeper!

    Model Context Protocol (MCP) is a shared communication language that enables AI agents to work together in modular, scalable systems. Unlike traditional API gateways, MCP allows context-aware agents to communicate with specialized services and delegate tasks to other agents through protocols like Agent2Agent. This creates composable, decentralized AI systems where multiple specialized agents collaborate rather than relying on a single large model.

  9. 9
    Article
    Avatar of towardsdevTowards Dev·42w

    Implementing Distributed Locks Correctly

    Distributed locks coordinate access to shared resources across multiple processes by ensuring mutual exclusion. The guide covers common implementation pitfalls like single points of failure, missing TTLs, and lack of fencing tokens. It examines various solutions including RDBMS advisory locks, Redis simple locks, Redlock algorithm, ZooKeeper ephemeral sequential nodes, and etcd's Raft-based approach. Each method has different trade-offs in consistency, performance, and complexity. Fencing tokens are crucial for preventing stale lock holders from corrupting state after timeouts. The choice of locking mechanism should match the required safety guarantees and system constraints.

  10. 10
    Article
    Avatar of awegoAwesome Go·42w

    Peeking Inside MinIO: How This Object Storage Powerhouse Works

    MinIO is a high-performance, open-source object storage system built in Go that provides S3-compatible APIs. It uses erasure coding for data durability, supports horizontal scaling through distributed architecture, and stores data directly on the filesystem without databases. Key features include single binary deployment, consistent hashing for data distribution, built-in versioning and encryption, and excellent performance through minimal I/O operations and parallelism.

  11. 11
    Article
    Avatar of architectureweeklyArchitecture Weekly·45w

    The Order of Things: Why You Can't Have Both Speed and Ordering in Distributed Systems

    Distributed systems force a fundamental trade-off between ordering guarantees and performance. PostgreSQL prioritizes correctness through locking but suffers from contention under load. MongoDB optimizes for speed but requires handling eventual consistency at the application level. Kafka provides scalability through partitioning but only guarantees ordering within partitions. The article explores the technical mechanics behind these trade-offs, including transaction isolation, replication lag, and coordination costs, concluding that the solution is choosing appropriate guarantees for different use cases rather than seeking perfect solutions.

See all Distributed Systems archives