Best of Architecture — October 2025

1. 1
   Article

   freeCodeCamp·27w

   How to Improve Your Programming Skills by Building Games

   Building games teaches essential programming skills that extend beyond game development. Through creating games, developers learn systems thinking, event-driven architecture, performance optimization, and debugging complex states. Games force practical application of math concepts like vectors and trigonometry, while teaching component-based architecture similar to modern frameworks. The hands-on experience with user input handling, reusable code patterns, and creative problem-solving translates directly to building better web applications, backend services, and software systems. Even simple 2D games provide valuable lessons in modular design, UX instincts, and managing code complexity that traditional tutorials rarely offer.

   288

   19
2. 2
   Article

   gitconnected·29w

   How to Scale Like a Senior Engineer (Servers, DBs, LBs, SPOFs)

   Scaling systems is about solving problems incrementally, not jumping to complex solutions. Start with understanding single server limitations, identify bottlenecks (CPU, memory, disk I/O), then make informed decisions about vertical vs horizontal scaling. Database optimization is often the real bottleneck, not application servers. Load balancers require careful algorithm selection and configuration. Even redundant architectures have single points of failure that need identification and mitigation. The key is adding complexity only when necessary and understanding the tradeoffs at each step.

   282

   6
3. 3
   Article

   Hacker News·29w

   Your data model is your destiny

   A product's data model—the core concepts and objects it prioritizes—determines whether new features create compounding advantages or just add to a feature list. Companies like Slack (persistent channels), Notion (blocks), Figma (shared canvas), and Rippling (employee records) succeeded by choosing non-obvious data models that became impossible for competitors to replicate without rebuilding from scratch. As AI commoditizes code execution, the data model becomes the primary moat. Horizontal tools innovate on how products are built, while vertical tools succeed by elevating the right domain objects. The key is identifying the atomic unit of work in your domain and ensuring every new feature strengthens that central concept.

   120

   2
4. 4
   Article

   Salesforce Engineering·27w

   Architecting Multi-System Production Platform

   Salesforce built Digital Wallet, a consumption-based pricing platform serving 15,000+ organizations and generating $400M+ in annual contract value. The engineering team overcame significant challenges as Data Cloud's first customer, including implementing SOX-compliant metadata security through Strict System Mode, building a custom event subscriber processing 20M daily events, and architecting failover strategies for near real-time usage tracking. The platform integrates multiple systems using fan-out mechanisms for entitlement sync, implements Spark job failover between EMR-on-EKS and EMR-on-EC2 to avoid rate limits, and maintains billing accuracy through architectural separation of hourly customer-facing updates from monthly financial reconciliation. The system includes high-cardinality monitoring, automatic retry logic, and a month-long buffer for usage reconciliation before billing.

   106
5. 5
   Article

   Javarevisited·29w

   Stop Writing Database-Dependent Tests — Mock Your Data Access Layer

   Database-dependent tests are slow, fragile, and blur the boundaries between unit and integration testing. Mocking the data access layer through interfaces and dependency injection enables fast, isolated unit tests that focus on business logic rather than infrastructure. The recommended approach is to use mocks for 90% of tests while reserving database-touching integration tests for the remaining 10%, ensuring high coverage without sacrificing development speed.

   97

   10
6. 6
   Article

   Microservices.io·31w

   A must-read book - Architecture for Flow: Adaptive Systems with Domain-Driven Design, Wardley Mapping, and Team Topologies

   A recommendation for Susanne Kaiser's book that combines Domain-Driven Design, Wardley Mapping, and Team Topologies to build adaptive systems. The book addresses how IT organizations can adapt quickly in volatile business environments by applying these three methodologies together to achieve fast flow and organizational agility.

   96

   1
7. 7
   Article

   Javarevisited·29w

   What Spring Boot Taught Me About Clean Architecture

   A developer's journey from writing monolithic Spring Boot controllers to implementing Clean Architecture principles. The piece demonstrates how to refactor tightly-coupled code into layered architecture with proper separation of concerns, showing practical examples of moving business logic from controllers to service layers. It connects Clean Architecture concepts to SOLID principles and explains how proper layering improves testability and maintainability in Java applications.

   91

   3
8. 8
   Article

   Netflix TechBlog·29w

   How and Why Netflix Built a Real-Time Distributed Graph: Part 1 — Ingesting and Processing Data Streams at Internet Scale

   Netflix built a Real-Time Distributed Graph (RDG) to analyze member interactions across different business verticals like streaming, gaming, and live events. The system processes over 1 million Kafka messages per second using Apache Flink jobs that transform events into graph nodes and edges, writing more than 5 million records per second to storage. The architecture evolved from a monolithic Flink job to a 1:1 mapping between Kafka topics and Flink jobs for better operational stability and tuning. This first part covers the ingestion and processing pipeline, with future posts planned for storage and serving layers.

   82
9. 9
   Video

   Continuous Delivery·31w

   Why Are Software Engineers Quitting Microservices?

   Explores the recent discourse around developers abandoning microservices, analyzing whether this trend is real and justified. Examines a widely-cited Amazon case study that moved from microservices to a monolith, questioning whether their original implementation was truly microservices-based. Discusses the inherent complexity of microservices, including distributed systems challenges, the need for sophisticated development practices like continuous delivery and contract testing, and proper service boundaries aligned with business capabilities. Argues that microservices remain the best solution for scaling development teams but come with significant overhead that makes them unsuitable for small teams, emphasizing that success requires careful design of service interfaces and organizational decentralization.

   74

   6
10. 10
    Article

    Dev World·30w

    Agile is Out, Architecture is Back!

    As AI-generated code transforms development workflows, the industry faces a new challenge: maintaining cohesive long-term structure. While Agile methodologies improved speed and flexibility, the focus is shifting back to architectural frameworks and processes that guide both developers and AI assistants to prevent technical debt and ensure maintainability over time.

    74

    9
11. 11
    Article

    System Design Newsletter·31w

    System Design Interview: Design Spotify

    A comprehensive guide to designing a music streaming platform like Spotify for system design interviews. Covers architecture components including blob storage for audio files, SQL databases for metadata, CDN integration, and API design. Explores capacity planning for 500K users and 30M songs, read/write workflows, and scaling strategies like database replication, sharding, and horizontal scaling. Includes practical considerations for audio delivery, caching, reliability patterns, and monitoring metrics.

    68

    2
12. 12
    Article

    Kashitsuwa·30w

    I finally built the Go project generator I always wanted: Goca (Beta)

    Goca is an open-source CLI tool that automatically generates production-ready Go features following Clean Architecture principles. It creates entities, use cases, repositories, and HTTP handlers to eliminate repetitive boilerplate code when starting new Go services. Currently in beta with MIT license, the tool aims to reduce setup time while enforcing architectural best practices.

    59

    6
13. 13
    Article

    Groww Engineering·30w

    A Framework for Cloud Cost Optimization: How We Saved 40% of our Cloud cost

    Groww Engineering reduced their cloud costs by 40% over three months through a systematic framework combining visibility, ownership, and architectural changes. They built an internal FinOps dashboard for granular cost tracking, standardized resource labeling across teams, shifted from fixed to elastic infrastructure, deprecated legacy services, migrated analytics to an in-house query engine, and established continuous optimization practices with team-level budgets and regular audits.

    54
14. 14
    Article

    Lobsters·29w

    Software can be finished

    Explores the concept of "finished software" as a thought experiment to challenge conventional development practices. Defines finished software as feature-complete, secure, and standalone with minimal dependencies. Uses examples like the Nintendo Gameboy, embedded systems, and small JavaScript apps to illustrate software that requires no updates. Discusses principles for building finished software: understanding requirements deeply, keeping scope small, reducing dependencies, producing static output, and increasing quality assurance. Emphasizes this as a theoretical framework for thinking about trade-offs rather than a universal goal.

    51

    2
15. 15
    Article

    Marvin Hagemeister·27w

    Building From First Principles

    Explores the disconnect between online framework-centric discussions and offline developers who build robust, maintainable applications using vanilla JavaScript and minimal tooling. Emphasizes how focusing on first principles—understanding the actual problem, prioritizing user experience, and choosing the simplest path—leads to clearer, more maintainable code. Advocates for pragmatic minimalism over framework dependency, showing that effective software development doesn't require following trending tools or methodologies.

    47

    9
16. 16
    Article

    Hacker News·29w

    Why is everything so scalable?

    A critical examination of the trend toward over-engineering for scale in startups. The author argues that most companies prematurely adopt complex, distributed architectures (microservices, cloud infrastructure, orchestrators) designed for FAANG-scale problems they don't have. Instead, they advocate for starting with a well-structured monolith using modular design with strict interface boundaries, static typing, and enforced separation of concerns. This approach provides clean architecture, atomic deployments, better type safety, and significantly lower costs while deferring the complexity of distributed systems until actually needed.

    47

    4
17. 17
    Article

    stitcher.io·28w

    Stitcher.io

    A refactoring case study that simplified a content scheduling system by eliminating a state transition and cron job. The original design used three states (PENDING, SCHEDULED, PUBLISHED) with automated transitions, requiring cron jobs, console commands, and complex logic. The refactor removed the SCHEDULED state and added a future-dated publicationDate field to PUBLISHED posts, using a SQL query to find available time slots. This eliminated moving parts like cron jobs and automatic state transitions, trading one type of complexity for another. The key insight: modeling software directly from human processes doesn't always yield the simplest technical solution.

    44
18. 18
    Video

    Matt Pocock·30w

    OpenAI just confused everyone again

    OpenAI's new Agent Kit sparked debate about the definition of AI agents versus workflows. An agent is a loop where the LLM decides when to stop, calling tools iteratively to gain new information. A workflow uses predetermined steps with known code paths. Agents excel at improvisation and unclear solution paths (like coding assistants), while workflows are better for repetitive tasks with optimization opportunities. Most real-world systems exist on a spectrum between these patterns, combining both approaches. The distinction matters for understanding trade-offs and communicating system design effectively.

    41

    1
19. 19
    Article

    API Evangelist·29w

    Applying Domain-Driven Driven Design to Integration and Consumption

    Explores applying domain-driven design principles to API consumption and integration, not just production. Discusses how concepts like bounded contexts, ubiquitous language, and aggregates help API consumers manage third-party services by establishing control over how multiple APIs work together, even when individual API designs are outside their control. Challenges the notion that DDD only applies to API producers.

    40

    3
20. 20
    Article

    Go Developers·30w

    I finally built the Go project generator I always wanted: Goca (Beta)

    Goca is an open-source CLI tool that automatically generates production-ready Go features following Clean Architecture principles. It creates entities, use cases, repositories, and HTTP handlers to eliminate repetitive boilerplate code when starting new Go services. Currently in beta with MIT license, the tool aims to reduce setup time while enforcing architectural best practices.

    35

    6
21. 21
    Article

    marmelab·31w

    Do you need a Backend For Frontend?

    The Backend-for-Frontend (BFF) pattern addresses common issues in multi-client applications where frontend teams struggle with API complexity and performance problems. A BFF acts as a dedicated translation layer between frontends and backend services, aggregating data and handling client-specific logic. While it can dramatically improve development velocity and mobile performance, it's not suitable for simple applications or small teams due to increased operational complexity.

    33
22. 22
    Article

    Machine Learning Mastery·28w

    7 Must-Know Agentic AI Design Patterns

    Seven proven design patterns for building production-ready AI agents: ReAct (reasoning loops), Reflection (self-critique), Planning (task decomposition), Tool Use (external integrations), Multi-Agent Collaboration (specialized agents), Sequential Workflow (fixed pipelines), and Human-in-the-Loop (safety checkpoints). Each pattern addresses specific trade-offs between cost, latency, reliability, and complexity. The guide emphasizes starting simple with single agents and tool use, then evolving to more complex patterns only when clear limitations emerge. Includes practical decision framework based on workflow predictability, quality requirements, and task complexity.

    32

    1
23. 23
    Article

    Charity·30w

    Got opinions on observability? I could use your help (once more, with feeling)

    Charity Majors is seeking community input for the second edition of her observability book, specifically requesting experiences and opinions on vendor migrations, cost management strategies for traditional three-pillar architectures, observability team structures, OpenTelemetry adoption decisions, and build-vs-buy considerations. She emphasizes that vendor engineering and software procurement are high-leverage activities requiring deep technical expertise, and shares specific questions about managing observability tools at scale, including migration playbooks, cost control tactics, and instrumentation automation.

    32
24. 24
    Article

    Ayende @ Rahien·30w

    The cost of design iteration in software engineering

    Software changes carry significant costs despite the lack of physical constraints. Modifying established codebases requires careful consideration of database migrations, backward compatibility, user workflows, and system integrations. Even simple changes like adding a field can cascade into major engineering efforts involving UI updates, data migration, and workflow adjustments. Large, mature systems with millions of lines of code face constraints similar to physical engineering, where iterations become increasingly expensive as systems mature beyond the initial draft stage.

    31
25. 25
    Video

    YouTube·28w

    Design Spotify Like a Senior Engineer (System Design Interview)

    A comprehensive walkthrough of designing a music streaming platform like Spotify, covering requirements gathering, capacity planning, high-level architecture, API design, database schema, and scalability strategies. The guide demonstrates how to handle 500,000 users and 30 million songs initially, then scale to 50 million users and 200 million songs using techniques like CDN distribution, database sharding, read replicas, and regional blob storage. Emphasizes the importance of planning and architecture over immediate coding, highlighting the skill progression from mid-level to senior engineering roles.

    28