Best of Architecture — November 2025

1. 1
   Article

   Amir·24w

   Is Frontend Dead? The Evolution You Can't Ignore

   Frontend development has evolved from simple UI work into full-system engineering. Modern frameworks like Next.js blur client-server boundaries with server components, edge deployment, and integrated data fetching. Developers now handle state management, security, performance optimization, and deployment—responsibilities traditionally split between frontend and backend roles. The shift demands understanding the complete user experience stack, from rendering strategies to authentication flows. This evolution creates opportunities for those who adapt by either broadening their skills across the full stack or specializing deeply in performance and user experience.

   872

   92
2. 2
   Article

   DEV·23w

   You're Not Building Netflix: Stop Coding Like You Are

   Over-engineering is a common trap for intermediate developers who apply enterprise patterns and abstractions to simple problems. The article argues against premature abstraction, showing real examples of unnecessarily complex code that could be replaced with straightforward solutions. Key principles include: abstract only what changes frequently, wait for three use cases before creating abstractions, avoid interfaces with single implementations, and prioritize readability over architectural sophistication. Simple, boring code that solves actual problems scales better than over-architected solutions designed for hypothetical future requirements.

   673

   55
3. 3
   Article

   Javarevisited·27w

   6 Must-Read Books for Backend Developers in 2026

   A curated list of six essential books for backend developers covering software architecture, design patterns, distributed systems, microservices, and data engineering. The recommendations include classics like "Designing Data-Intensive Applications" by Martin Kleppmann, "The Pragmatic Programmer," and "Building Microservices" by Sam Newman, focusing on fundamental principles that remain relevant despite changing frameworks and tools. Each book addresses critical aspects of backend development from API design and scalability to data pipelines and architectural trade-offs.

   354

   2
4. 4
   Article

   System Design Newsletter·25w

   21 Frontend System Design Concepts for Software Engineers

   A comprehensive guide covering 21 frontend system design concepts organized into five categories: rendering strategies (SSG, ISR, SSR, CSR, hybrid), performance optimization (lazy loading, caching, service workers), data management (state management, API strategies, real-time updates), architecture patterns (micro frontends, component systems, CI/CD), and reliability considerations (accessibility, PWAs, security, observability). Explains how frontend engineering mirrors backend system design principles, with practical examples of when to use each approach for building fast, scalable web applications.

   172

   9
5. 5
   Article

   Docker·23w

   You Want Microservices—But Do You Need Them?

   Microservices have become the default architectural choice despite their significant complexity costs. Amazon Prime Video achieved 90% cost reduction by reverting to a monolith, while companies like Twilio Segment and Shopify found success with simpler architectures. Industry leaders including GitHub's former CTO and GraphQL's co-creator warn that most organizations lack the scale to justify microservices overhead. The operational costs, developer productivity drain, testing complexity, and data consistency challenges often outweigh benefits. Modular monoliths and service-oriented architectures offer comparable scalability without distributed system complexity. Docker provides deployment consistency across any architecture, not just microservices. The key question: does your actual scale and team structure justify the microservices premium, or are you choosing complexity over business needs?

   149

   11
6. 6
   Article

   Anubhav Bhatt·25w

   Pub/Sub Model Saved Our Insurance System from Collapse

   A tightly coupled insurance policy activation system was failing when any downstream service experienced an outage. By refactoring from sequential service calls to an event-driven pub/sub architecture using Kafka, the system became resilient and decoupled. Each service now independently subscribes to policy activation events, allowing failures to be isolated and new services to be added without modifying core logic.

   108

   12
7. 7
   Video

   CodeHead·25w

   Why Dev Projects Use Multiple Languages?

   Modern software projects use multiple programming languages because different languages excel at different tasks. Frontend requires JavaScript for browser compatibility, while backend services benefit from specialized languages like Go for low-latency networking, Python for data science, and Java for enterprise workloads. Major platforms like YouTube, Netflix, and Instagram combine multiple languages strategically. Services communicate through APIs, gRPC, and message queues, with containerization making polyglot architectures practical. Teams choose languages based on performance needs, developer expertise, and existing system compatibility, trading monolithic simplicity for distributed system flexibility.

   104

   5
8. 8
   Article

   WebCraft·23w

   Is Frontend Dead? The Evolution You Can't Ignore

   Frontend development has evolved from simple UI work into full-system engineering. Modern frameworks like Next.js blur client-server boundaries with server components, edge deployment, and integrated data fetching. Developers now handle state management, security, performance optimization, and deployment—responsibilities traditionally split between frontend and backend roles. The shift demands understanding the complete user experience stack, from rendering strategies to authentication flows. This evolution creates opportunities for those who adapt by either broadening their skills across the full stack or specializing deeply in performance and user experience.

   101

   11
9. 9
   Article

   Yegor's Blog·25w

   Small Repo, High Quality

   Breaking software into smaller repositories instead of using monolithic repos improves code quality through stricter style enforcement, deeper testing, more thorough code reviews, better documentation, faster release cycles, improved AI agent effectiveness, quicker onboarding, stronger code ownership, and easier open-source adoption. While companies like Google and Facebook favor monorepos for reduced integration overhead, smaller repositories enable teams to maintain higher quality standards across multiple dimensions of software development.

   99

   11
10. 10
    Article

    marmelab·25w

    Spec-Driven Development: The Waterfall Strikes Back

    Spec-Driven Development frameworks like Kiro and Spec-kit generate extensive Markdown documentation before coding, echoing Waterfall methodology. While promising structure for AI coding agents, this approach creates context blindness, excessive documentation review, and diminishing returns on large codebases. The author argues for Natural Language Development instead: an iterative, Agile-inspired approach where developers give coding agents simple, incremental instructions without formal specifications, enabling faster convergence toward working products.

    91

    10
11. 11
    Article

    Microservices.io·23w

    Berlin meetup: Microservices rules - what good looks like

    A presentation covering 11 development and architecture rules for successfully implementing microservices. Addresses common pitfalls where organizations struggle with microservices adoption, creating unmaintainable legacy applications instead of improving developer experience and accelerating software delivery. Focuses on best practices to prevent microservices-based applications from becoming difficult to change.

    79

    1
12. 12
    Article

    Javarevisited·25w

    Don’t Ignore Thread Safety — Design for Concurrency from Day One

    Concurrency bugs are non-deterministic, hard to reproduce, and often emerge only under production load, making them far more dangerous than typical logic errors. Building thread-safe systems from the start requires adopting design principles like immutability, avoiding shared state, using concurrency-safe primitives, and reviewing code with concurrency in mind. AI-powered code review tools can automatically detect unsafe shared variables, missing synchronization, potential deadlocks, and race conditions during pull requests, catching issues before they reach production. As modern applications become increasingly distributed and parallel, treating concurrency as a baseline engineering skill rather than an afterthought is essential for building scalable, maintainable systems.

    79

    1
13. 13
    Article

    Milan Jovanović·23w

    Vertical Slice Architecture: Where Does the Shared Logic Live?

    Vertical Slice Architecture offers flexibility but creates challenges around shared code placement. The article proposes a three-tier framework: freely share technical infrastructure (logging, database connections), push domain logic into entities and value objects, and keep feature-specific logic local within feature folders. Cross-feature sharing should be minimized—most cases are actually data access in disguise. The key principle is that duplication is often cheaper than premature abstraction, and code should be organized by its nature (domain, infrastructure, or cross-cutting) rather than forced into a common junk drawer.

    78

    4
14. 14
    Article

    DEV·25w

    "Technical Debt Will Bite Us in the Ass": How to Make Non-Technical Stakeholders Actually Care

    Engineers often struggle to get stakeholders to prioritize technical debt because they use technical jargon instead of business language. The key is translating code quality issues into tangible business impacts using relatable metaphors (infected wounds, cracked foundations) and quantifiable metrics (time, money, bug rates). Frame technical debt discussions by acknowledging stakeholder priorities first, connecting technical problems to their goals, quantifying costs, proposing clear ROI, and empowering them to make informed decisions. Cross-discipline communication isn't a soft skill—it's a core engineering competency.

    78

    13
15. 15
    Article

    Shefali·25w

    21 Frontend System Design Concepts for Software Engineers

    A comprehensive collection of 21 essential system design concepts specifically for frontend development. Covers critical topics including performance optimization, caching strategies, API design patterns, state management, rendering techniques, security considerations, accessibility, and scalability. Each concept is explained with practical context for building robust, production-ready web applications.

    77

    4
16. 16
    Article

    The New Stack·24w

    The React Component Pyramid Scheme: An Over-Engineering Crisis

    The pursuit of reusable React components has created over-engineered codebases filled with complex abstractions and prop-heavy components that are harder to maintain than simpler alternatives. The DRY principle, when applied dogmatically, leads to premature abstraction and components like Button.jsx that try to handle every use case with dozens of props and conditionals. Intentional code duplication is often more pragmatic than forced reuse, as it preserves clarity and allows code to evolve independently. The solution is adopting a post-reuse mindset that values simple, self-contained, context-aware components over universal abstractions, recognizing that the best component is one you can understand instantly rather than one you can use everywhere.

    74

    4
17. 17
    Article

    Slack engineering·26w

    Build better software to build software better

    Slack's engineering team reduced their build pipeline time from 60 minutes to as little as 10 minutes by applying software engineering principles to their build system. They migrated to Bazel while addressing fundamental architectural issues: breaking circular dependencies between frontend and backend code, separating build logic from application code, and creating granular, cacheable build units. The key insight was treating build performance like code performance—optimizing through caching and parallelization while maintaining hermetic, idempotent build steps. This required months of refactoring to properly separate concerns across Python backend, TypeScript frontend, and build orchestration layers.

    67

    3
18. 18
    Article

    Ruby Flow·25w

    Growing Software

    Software development benefits from patience and organic growth rather than premature optimization. Complex architectures and abstractions should emerge from actual pain points in the codebase, not from theoretical best practices applied too early. Like tending a garden, developers should let code evolve naturally, refactoring only when the need becomes evident through real usage and maintenance challenges. This approach avoids over-engineering and keeps codebases simpler and more maintainable.

    59

    4
19. 19
    Article

    ByteByteGo·25w

    EP189: How to Design Good APIs

    Covers fundamental principles of API design including idempotency, versioning, resource naming, security, and pagination. Explores big data pipeline architectures across AWS, Azure, and GCP. Provides a structured learning path for AWS services from fundamentals through certifications. Explains RAG application architecture on AWS and compares virtualization approaches from bare metal to containers on VMs.

    52
20. 20
    Article

    AppSignal·25w

    Diving Into Reactive Programming in Node.js

    Reactive programming treats data streams as first-class citizens, allowing code to automatically respond to data changes. While Node.js doesn't natively support this paradigm, libraries like RxJS and Bacon.js enable it through core concepts including Observables, Observers, Subscriptions, Operators, and Subjects. The approach offers enhanced scalability, reduced coupling, and improved fault tolerance for event-driven architectures, though it introduces complexity and debugging challenges. RxJS dominates the ecosystem with 68 million weekly downloads, supporting both cold and hot observables with extensive operators for transforming data streams. Compared to imperative programming's explicit instructions, reactive programming declaratively describes what should happen in response to events, making it particularly valuable for handling complex asynchronous workflows in microservices and real-time systems.

    52
21. 21
    Article

    Frederick's delirious rantings·27w

    Architectural debt is not just technical debt

    Architectural debt extends far beyond code-level technical debt into business and strategic layers. While developers focus on code patterns and structure, enterprise architects must address application integration patterns, data flows, vendor lock-in, business process documentation, ownership clarity, and strategic framework alignment. Debt at the business layer creates operational inefficiencies and compliance risks, while strategic-level debt can derail multi-year transformation initiatives. Enterprise architects have the visibility and access to flag these issues through dashboards and business cases, but must prioritize battles carefully and be prepared to lead remediation efforts themselves.

    48

    3
22. 22
    Article

    TkDodo·25w

    Tooltip Components Should Not Exist

    Standalone tooltip components in design systems often lead to accessibility problems and inconsistent user experiences. The core issue is that low-level tooltip components allow developers to attach tooltips to non-interactive elements, breaking keyboard navigation and creating unpredictable UX patterns. Instead of exposing a generic Tooltip component, design systems should provide higher-level pattern components like IconButton with required titles, InfoIcon components, and InfoText elements that enforce accessible, consistent tooltip behavior by design. This restrictive approach ensures keyboard interactivity, visual discoverability, and proper accessibility labeling while preventing common misuse patterns.

    43

    5
23. 23
    Article

    Hacker News·26w

    What the hell have you built.

    A reminder to developers about the dangers of over-engineering. Building complex systems with minimal users (often mostly test accounts) defeats the purpose. Good architecture should be explainable without convoluted diagrams. The key principle: start with simple solutions and only introduce complexity when there's concrete evidence it's necessary.

    42

    5
24. 24
    Article

    Hacker News·25w

    When did people favor composition over inheritance?

    Explores the historical origins and context of the "favor composition over inheritance" principle from the Gang of Four's Design Patterns book. Examines the three-page discussion that led to this aphorism, including the white-box versus black-box reuse distinction, language-specific considerations in Smalltalk and Java, and the compile-time versus runtime trade-offs. References Barbara Liskov's earlier work on subtypes and polymorphism, highlighting that composition and inheritance aren't the only options—first-class procedures offer a third alternative that the simplified aphorism overlooks.

    41

    6
25. 25
    Article

    Javarevisited·26w

    Why I Implemented a Custom Serializer/Deserializer for JJWT Instead of Using jjwt-jackson

    A developer explains their decision to build a custom JSON serializer/deserializer for JWT handling instead of using the popular Jackson library. The custom implementation reduces security vulnerabilities from external dependencies, maintains framework consistency with existing tooling, provides better control over predictable JWT payloads, and eliminates unnecessary complexity. The lightweight codec integrates seamlessly with JJWT through its SPI mechanism while keeping the codebase transparent and maintainable.

    40

    3