Best of Architecture — September 2025

1
Article
System Design Newsletter·35w
7 Best Practices for API Design 🔥
Seven essential practices for designing robust APIs: REST fundamentals for organizing data resources, proper error handling with clear status codes, API versioning for backward compatibility, rate limiting to prevent abuse, pagination techniques (offset vs cursor) for large datasets, idempotency to avoid duplicate processing, and filtering/sorting for efficient data retrieval. Each practice includes implementation details and trade-offs to consider.
673
19
2
Article
Lobsters·35w
If I hear "design pattern" one more time, I'll go mad
A critical examination of design patterns in software development, arguing that many patterns are overcomplicated names for simple programming concepts. The author contends that patterns like Command (which is just a function) and Strategy (which is just an interface) create unnecessary cognitive overhead and that developers naturally arrive at these solutions through iterative design without needing formal pattern terminology. The piece advocates for focusing on underlying principles rather than memorizing pattern names, suggesting that good architecture emerges from composing language features to solve problems rather than following prescribed patterns.
143
31
3
Article
Javarevisited·35w
How ByteByteGo Helps You Transition from Senior Engineer to Architect?
ByteByteGo offers structured learning paths for senior engineers transitioning to software architect roles through visual system design guides, real-world case studies, and comprehensive coverage of architectural concepts. The platform provides systematic progression from basic concepts like load balancing and caching to advanced topics like sharding and consensus protocols, helping engineers develop the system-level mindset required for architecture positions.
141
1
4
Article
Hacker News·33w
AI Was Supposed to Help Juniors Shine. Why Does It Mostly Make Seniors Stronger?
AI tools in software development are primarily benefiting senior developers rather than empowering juniors as initially expected. While AI excels at generating boilerplate code and automating repetitive tasks, it struggles with code review, architecture design, security considerations, and quality assessment. Senior developers can better leverage AI's strengths while avoiding its pitfalls, as they possess the experience to write effective prompts, evaluate AI-generated code, and maintain proper software architecture. The current state suggests AI is concentrating power among experts rather than democratizing coding skills.
122
29
5
Article
Javarevisited·34w
How I Combined ByteByteGo and Codemia.io to Crack System Design Interviews in 2025
A developer shares their successful strategy for system design interview preparation by combining ByteByteGo's visual learning approach with Codemia.io's hands-on practice platform. ByteByteGo provided conceptual understanding through industry-leading diagrams of real systems like Twitter and Uber, while Codemia.io offered practical experience with actual interview problems and AI-driven feedback. This dual approach helped the author secure multiple FAANG offers by mastering both theoretical concepts and practical application skills.
85
4
6
Article
Hacker News·35w
How did MVC get so F’ed up?
The Model-View-Controller (MVC) pattern has been misunderstood and misimplemented over the years. The original Smalltalk MVC design keeps models completely unaware of views and controllers, using observer patterns for communication. Modern implementations, particularly Apple's Cocoa version, have corrupted this by making controllers act as intermediaries and creating tightly coupled view-controllers. True MVC requires observable models that can notify multiple views of changes, with the key insight being that models should never depend on their UI components. The pattern works as a composite where views can have their own models, and even function arguments should be treated as observable models to properly enable/disable UI elements.
84
7
7
Video
YouTube·34w
How to Design APIs Like a Senior Engineer (REST, GraphQL, Auth, Security)
A comprehensive guide covering advanced API design principles that distinguish senior engineers from junior developers. Explores REST, GraphQL, and gRPC architectures, application protocols (HTTP, WebSockets, AMQP), transport layer protocols (TCP/UDP), and authentication methods including OAuth2 and JWT tokens. Covers practical aspects like resource modeling, status codes, error handling, filtering, pagination, and security best practices for building scalable, maintainable APIs.
82
1
8
Article
InfoQ·34w
Thinking Like an Architect
Gregor Hohpe redefines the architect role as an "IQ booster" who makes teams smarter rather than making all decisions. He introduces the "Architect Elevator" concept for connecting different organizational levels, emphasizes using metaphors to communicate technical concepts to business stakeholders, and presents architects as option traders who help organizations defer decisions until more information is available. The talk covers practical strategies for handling resistance, using models effectively, and thinking multidimensionally about problems like vendor lock-in.
77
9
Article
System Design Codex·33w
Most Important Tips for System Design Interviews
A comprehensive guide covering 23 essential principles for system design interviews, including scaling strategies (vertical then horizontal), caching for read-heavy systems, database optimization techniques, load balancing, and architectural patterns. Emphasizes the importance of clarifying requirements, considering trade-offs, and maintaining interactive communication during interviews rather than seeking perfect solutions.
77
10
Article
ByteByteGo·33w
How Anthropic Built a Multi-Agent Research System
Anthropic built a multi-agent research system using an orchestrator-worker pattern with a Lead Researcher agent coordinating specialized subagents and a Citation Agent for accuracy. The system outperformed single-agent setups by 90% through parallel processing and dynamic adaptation, though it consumes 15x more tokens. Key engineering principles include proper prompt design, delegation strategies, effort scaling, and parallelization. Production challenges involve managing stateful agents, debugging non-deterministic behavior, and handling deployments without breaking running tasks.
74
11
Article
OpenSouls·33w
UUIDv47
UUIDv47 is a library that enables reversible transformation between UUIDv7 (time-ordered) and UUIDv4 (random-appearing) formats. It allows developers to hide time-ordering from external APIs while maintaining internal chronological benefits, using cryptographically secure SipHash-2-4 algorithm with high performance and zero dependencies.
68
3
12
Article
Javarevisited·36w
Why Software Architecture Skills Are the Key to Job Security in the Age of AI? (with Resources)
Software architecture skills provide job security as AI automates coding tasks. While AI can replace basic programming, architectural thinking—designing complex systems, making trade-offs, and guiding technical decisions—remains irreplaceable. The article promotes the Certified Professional for Software Architecture (CPSA) training as a structured path for senior engineers to transition into architect roles, highlighting significant salary increases and better career prospects for those with architecture expertise.
67
1
13
Article
GitHub Blog·31w
Spec-driven development: Using Markdown as a programming language when building with AI
A developer shares an experimental approach to building applications by writing specifications entirely in Markdown and using GitHub Copilot to compile them into actual code. The workflow involves maintaining app logic in markdown files, using AI to generate Go code, and keeping documentation synchronized with implementation. This spec-driven development method aims to solve context loss issues with AI coding agents while enabling faster iteration and cleaner specifications.
66
10
14
Article
Confluent Blog·32w
Why Microservices Need Event-Driven Architectures for Agility and Scale
Event-driven architectures solve critical problems in microservices by replacing synchronous API calls with asynchronous event communication. This approach eliminates bottlenecks, prevents cascading failures, and enables real-time responsiveness. Apache Kafka serves as the central platform for event streaming, allowing services to publish and subscribe to events independently. The shift from REST-based to event-driven microservices delivers faster innovation cycles, improved system resilience, and better customer experiences across industries like finance, e-commerce, and telecommunications.
65
15
Article
freeCodeCamp·34w
How to Extend CRUD Operations to Align with Business Workflows
CRUD operations work well for simple applications but become problematic at scale when business workflows require domain-specific actions. Instead of generic create, read, update, delete operations, APIs should model actual business processes like submit, approve, reject, and withdraw. This approach improves authorization, auditability, and workflow enforcement while making the system's intent clearer and reducing security risks.
62
16
Article
Architecture Weekly·35w
Just use SQL they say... Or how accidental complexity piles on
Explores how the seemingly simple approach of "just use SQL" can lead to accidental complexity as requirements grow. Starting with basic SQL queries in TypeScript, the article demonstrates how adding features like filtering, parameterization for SQL injection prevention, and dynamic query building quickly escalates into building a custom query compiler. The piece argues that while "just" solutions work initially, they often evolve into the same complexity that existing tools were designed to solve, emphasizing the importance of considering long-term needs when choosing between DIY and established solutions.
59
4
17
Article
Oxide·33w
Systems Software in the Large
Systems software development becomes exponentially more challenging when scaled to large, multi-component projects. The intersection of systems programming complexity with large-scale software development creates some of the most difficult engineering problems. Oxide's software update system exemplifies this challenge, requiring dynamic updates of distributed systems while maintaining operability and working across air-gapped environments. The post highlights lessons learned from leading such projects, including managing scope creep, organizational procrastination, and technical decision-making in complex systems.
59
18
Article
WebDev·33w
UUIDv47
UUIDv47 is a library that enables reversible transformation between UUIDv7 (time-ordered) and UUIDv4 (random-appearing) formats. It allows developers to hide time-ordering from external APIs while maintaining internal chronological benefits, using cryptographically secure SipHash-2-4 algorithm with high performance and zero dependencies.
57
7
19
Article
Nestjs Developers·32w
UUIDv47
UUIDv47 is a library that enables reversible transformation between UUIDv7 (time-ordered) and UUIDv4 (random-appearing) formats. It allows developers to hide time-ordering from external APIs while maintaining internal chronological benefits, using cryptographically secure SipHash-2-4 algorithm with high performance and zero dependencies.
46
8
20
Article
shipping bytes·32w
Buy vs build when it comes to dependency management
Explores the evolution of developer perspectives on dependencies across career stages, from junior engineers wanting to learn by avoiding them, to mid-level developers embracing them for speed, to senior engineers being cautious about complexity. Compares software dependency decisions to manufacturing choices, arguing that both require careful cost-benefit analysis rather than blanket rules.
36
3
21
Article
Go·34w
A new experimental Go API for JSON
Go 1.25 introduces experimental encoding/json/v2 and encoding/json/jsontext packages to address long-standing issues in the original encoding/json package. The new v2 API fixes behavioral flaws like invalid UTF-8 handling and duplicate JSON keys, improves performance especially for unmarshaling (up to 10x faster), and provides better streaming capabilities. The jsontext package handles JSON syntax while v2 manages semantics, offering new interfaces like MarshalerTo and UnmarshalerFrom for better performance. The original v1 package will be reimplemented using v2 under the hood, allowing gradual migration while maintaining backward compatibility.
34
22
Article
Lea Verou·32w
In the economy of user effort, be a bargain, not a scam • Lea Verou
User effort should be treated as a currency that users spend to accomplish their goals. The key to great product design is creating a smooth complexity-to-effort curve where simple tasks remain easy while complex tasks are possible, avoiding usability cliffs where slight increases in complexity cause dramatic jumps in required effort. Products should maximize signal-to-noise ratio by eliminating unnecessary steps and boilerplate, prioritize consumer needs over producer needs, and design tradeoffs that make users feel they're getting a bargain rather than being overcharged for basic functionality.
32
3
23
Article
freeCodeCamp·32w
How to Implement Dependency Injection in Go - Explained with Code Examples
Dependency injection (DI) in Go involves passing dependencies into components rather than creating them internally, making code more testable and maintainable. The guide covers manual DI as the idiomatic Go approach, explains when complexity grows with nested dependencies, and explores DI libraries like Google Wire (compile-time), Uber Dig (runtime), and Uber Fx (with lifecycle management). Manual DI works well for most projects, while frameworks help manage complexity in larger applications. Best practices include keeping dependencies explicit, starting simple, and using interfaces for testability.
28
24
Article
Spring·33w
API Versioning in Spring
Spring Framework 7 introduces official API versioning support with ApiVersionStrategy for server-side handling and ApiVersionInserter for client requests. The feature supports various versioning approaches including path, header, query parameter, and media type versioning. Key capabilities include semantic version parsing, baseline versioning with '+' notation, deprecation headers following RFC standards, and comprehensive testing support through RestTestClient, WebTestClient, and MockMvc.
25
25
Video
The Cherno·33w
C++ Application Architecture - A Mini-Series
A comprehensive guide to architecting C++ applications using a modular approach that separates core reusable systems from application-specific code. The tutorial demonstrates building a clean architecture with an application system, window management, main loop, and layer-based functionality using OpenGL. Key concepts include creating a core static library for reusable components, implementing a layer system for custom behavior, and maintaining clean separation between framework code and application logic. The approach emphasizes simplicity and reusability, making it easier to create multiple applications without reimplementing core functionality.
23

See all Architecture archives