Best of Architecture — May 2025

1
Article
Javarevisited·51w
Microservices Architecture
Microservices architecture is advocated as an alternative to the monolithic style, offering scalability, flexibility, and independent deployment. It involves breaking down an application into multiple independent services, minimizing tight coupling and easing fault isolation. Considerations for adopting microservices include scalability needs, team expertise, and project complexity, while weighing their advantages and potential high setup costs and management complexity.
316
12
2
Article
Three Dots Labs·49w
Synchronous vs Asynchronous Architecture
Explores the trade-offs between synchronous and asynchronous architecture patterns for backend systems. Synchronous approaches offer simplicity and predictability but can create bottlenecks and tight coupling. Asynchronous patterns using message queues and events provide better scalability and resilience but introduce complexity in debugging, testing, and error handling. The discussion covers common anti-patterns like distributed monoliths, naive background processing approaches, and improper message ordering. Emphasizes that good design matters more than technology choice, and recommends starting with synchronous architecture by default, then adopting async patterns where they provide clear benefits like handling external API failures or traffic spikes.
300
3
3
Article
Medium·1y
21 Essential System Design Building Blocks for Software Engineers
System design is crucial for building scalable, efficient, and reliable systems. This post outlines 21 essential components such as CDN, databases, rate limiter, and API Gateway that form the foundation for robust system architecture. It emphasizes the importance of these building blocks in interviews and real-world applications like e-commerce platforms, and recommends resources for further learning.
263
2
4
Article
ByteByteGo·1y
EP161: A Cheatsheet on REST API Design Best Practices
REST API design involves best practices such as using resource-oriented paths, applying HTTP verbs properly, maintaining API versioning, and utilizing standard error codes. Ensuring APIs are idempotent and supporting pagination can enhance performance and reliability. Security measures like using API Keys, JWTs, OAuth2, and HTTPS are crucial for protecting APIs in production.
237
1
5
Video
Community Picks·50w
Multi-Tenant SaaS Architecture in 3 Simple Steps
The post explains how to build a multi-tenant SaaS application in three steps. It starts by defining multi-tenancy, designing an entity relationship diagram, and finally, creating a multi-tenant application where organizations can manage blog articles. The architecture uses a single application instance and database for all tenants, differentiating data with a tenant-specific identifier. It includes the use of authentication and roles to manage user access and permissions across organizations.
151
6
Article
System Design Codex·1y
Key API Design Considerations
A well-designed API is crucial for predictability, consistency, and scalability. Key considerations include defining clear interfaces, choosing the appropriate API paradigm (REST, GraphQL, or gRPC), modeling relationships effectively, implementing versioning strategies, and using rate limiting to manage requests. Treating APIs as products enhances their usability and maintainability.
135
2
7
Article
Architecture Weekly·1y
Why We Should Learn Multiple Programming Languages
Exploring the value of learning multiple programming languages, this piece highlights how language flexibility can enhance a developer's skills and adaptability. It discusses scenarios where adding a new language can be beneficial, such as solving specific business problems or improving hiring processes. It emphasizes thoughtful consideration of language changes to avoid unnecessary complexity and maintenance challenges, advocating collaboration across frontend and backend development areas.
129
9
8
Video
Theo - t3․gg·1y
Rate Limiting
Rate limiting is essential for controlling traffic and ensuring fair usage of resources in applications. The post explores common rate limiting algorithms, such as fixed window, sliding window, and token buckets, describing their benefits and drawbacks. It highlights practical applications in scenarios like preventing spam in chat services and protecting APIs from excessive requests. Additionally, the post emphasizes considerations for implementing rate limiting effectively, such as data storage and user communication.
111
2
9
Video
YouTube·51w
Let's build a multi-vendor E-Commerce SaaS by using Microservice Architecture, ImageKit | part (1/3)
Learn how to build a multi-vendor e-commerce SaaS platform using microservice architecture, incorporating advanced features such as real-time analytics and custom machine learning models for recommendations. The tutorial covers authentication systems, frontend and backend setup, message brokers for handling data traffic, and integration with technologies like TensorFlow and ImageKit.
105
10
Article
swizec.com·51w
Why websites and webapps are different
The post discusses the enduring debate between websites and webapps, emphasizing their distinct requirements and challenges. It explores how business growth complicates web development, leading to a shift towards frameworks like React for better componentization and UX. Through examples and experiences, it highlights the importance of composability and component guarantees to handle architectural complexity and improve development practices.
78
1
11
Article
theburningmonk.com·51w
Understanding push vs poll in event-driven architectures
Explore the differences between push and poll models in event-driven architectures, focusing on how they affect system design, event delivery, and error handling. Learn the pros and cons of both models, suitable use cases, and how Lambda's async invocations can convert push to poll and vice versa, assisting in stream processing and real-time event handling.
75
1
12
Article
ITNEXT·51w
Can Code Duplication Be a Good Thing?
Explores the idea that code duplication can sometimes be beneficial, challenging the widely accepted DRY principle. Highlights the pitfalls of premature abstraction, semantic overload, and coupling when adhering strictly to DRY. Provides guidelines for when code duplication might be appropriate and how to handle shared components effectively.
66
6
13
Article
System Design Codex·49w
Essential Components of a Production Level Microservice Application
Microservices architecture divides a system into independently deployable services, requiring attention to infrastructure, communication patterns, monitoring, and security. Key components include an API Gateway for unified client access, a Service Registry for dynamic service discovery, and a Service Layer for core business logic. Security is managed via an authorization server, while data storage is tailored to each service. Additional components include distributed caching, asynchronous communication, metrics collection, and log aggregation for enhanced performance and observability.
60
14
Article
ByteByteGo·51w
How Pinterest Scaled Its Architecture to Support 500 Million Users
Pinterest successfully scaled its architecture to support 500 million users by learning from early challenges and chaotic growth. Initially, it used a basic tech stack including Python, MySQL, and MongoDB. Facing rapid traffic growth, Pinterest introduced multiple databases like Cassandra and Redis to manage distributed data and caching needs. Eventually, the company realized the complexity was unsustainable and simplified its core components to MySQL, Redis, and Memcached. By focusing on operational clarity and system durability, Pinterest achieved stability and scalability, highlighting the importance of selecting reliable technologies and maintaining simplicity in architecture.
52
15
Article
Rust Developers·1y
Rust is not so complicated after all....
After exploring Rust, the author finds that despite its reputation, Rust's learning curve is not as steep as anticipated. The post shares insights on tooling, performance, domain-driven design, and the benefits of compile-time safety.
52
2
16
Article
ByteByteGo·51w
How Slack Supports Billions of Daily Messages
Slack supports billions of daily messages by maintaining over five million simultaneous WebSocket sessions at peak hours, addressing the architectural challenge of real-time interaction. Initially developed from a video game infrastructure, Slack's architecture separates message propagation from business logic and adopted a push-first model using WebSockets. Significant challenges included scaling session initialization for large teams and ensuring message persistence and order through atomic broadcast approximations. Innovations like Flannel and architectural shifts improved the system's resilience and efficiency at scale, embracing complexity where necessary while simplifying other areas.
47
1
17
Article
Hacker News·49w
LiveStore: Local-first data layer for high-performance apps
LiveStore is a state management framework utilizing reactive SQLite and event-sourcing for high-performance applications. It replaces traditional libraries like Redux and MobX, offering real-time sync capabilities and a type-safe schema API. LiveStore enables developers to build local-first, offline-first apps with complex data scenarios while providing advanced devtools for an optimal developer experience.
46
5
18
Article
Medium·51w
🧱 Architecting Laravel the Right Way: Modular Monoliths Done Right 🧩⚙️
Learn how to structure Laravel applications using a modular monolith approach to improve maintainability and enhance separation of concerns. Explore the benefits of defining clear internal modules, reducing bloated controllers, and promoting team collaboration without adopting the complexity of microservices.
46
19
Article
swizec.com·49w
Software architecture IS Conway's Law
Conway's Law states that organizations design systems that mirror their communication structures. When working solo, developers often create messy, tightly coupled code because there's no need for clear boundaries. However, when teams collaborate, they naturally create cleaner architecture by defining clear interfaces and splitting work into components. The key insight is that breaking down work into smaller steps, whether solo or in a team, leads to better architecture and more maintainable code.
45
20
Article
Microservices.io·50w
Microservices rules #8: Design independently deployable services
Designing independently deployable services is a key principle in microservice architecture. This concept involves creating services that can be deployed and updated without affecting other components, leading to greater agility and efficiency. The post discusses the importance of this characteristic, common pitfalls such as reliance on end-to-end testing, and strategies for transitioning to more flexible deployments.
34
21
Article
habr·50w
Designing Profitable Software: Architecture Principles for Business Success
The post discusses principles for designing profitable software by focusing on business logic, reducing technical challenges, and ensuring easy maintenance, scalability, and testing. It covers the benefits of distributed systems with stateless services and a separation of domain and integration layers for better scalability and reduced refactoring effort. Technology choices favor JVM-based languages like Kotlin for their rich ecosystem and ease of use with microservices, while avoiding scripting languages for production use.
33
22
Article
Nordic APIs·1y
Microservices vs. Monoliths: How to Choose the Right Architecture for Your Business
Deciding between microservices and monolithic architecture is crucial for new development projects, balancing scalability, complexity, team expertise, and business goals. Monoliths are simpler and cost-effective initially, while microservices offer greater flexibility and scalability for larger, complex systems. The choice depends on technical and business priorities, including deployment frequency, maintenance ease, initial vs. long-term costs, and compliance needs.
31
23
Article
Tech World With Milan·50w
The Art and Science of Architectural Decision-Making
Architecture Decision Records (ADRs) are essential for capturing significant design choices in software projects. They maintain a historical record of decisions, ensuring that the reasoning and context behind architecture choices are accessible. ADRs foster knowledge retention, enhance collaboration, and facilitate architectural evolution. Implementing them does not require special tools, as they can be simple text files in version control systems or written in wikis. Selecting the right tool and template helps establish efficient practices in software development teams.
26
24
Article
Community Picks·1y
Introducing Outpost: Open Source Outbound Webhooks and Event Destinations Infrastructure
Outpost is a self-hostable, open-source infrastructure tool for SaaS and API platforms, enabling reliable delivery of events through webhooks, message queues, and event buses. It offers features like observability, retry logic, and multi-tenancy support, simplifying event delivery while allowing full control over infrastructure, cost, and compliance.
26
25
Article
Stack Overflow Blog·1y
Mastering microservices with a former Uber and Netflix architect
Jeu, a former architect at Uber and Netflix, now cofounder of Orkes, shares insights on mastering microservices. Orkes offers a developer-first enterprise workflow orchestration platform. The post highlights contributions by Stack Overflow user Alex Stiff.
25

See all Architecture archives