Software Architecture and System Design News
Latest curated articles from top engineering blogs
Shopify
AWS382 articles
Architecting Full-Duplex AI Voice Agents with Delegated Reasoning
This article explores OpenAI's new GPT-Live-1 API, which introduces a full-duplex voice architecture for AI agents, collapsing the traditional chain of separate systems for speech-to-text, reasoning, and text-to-speech. It highlights a design pattern where a conversational frontend delegates heavier computational tasks to backend reasoning models, enabling more natural interactions and reducing developer complexity.
Application Networking Fundamentals for System Design
This article provides a foundational overview of application networking, detailing the journey of an API request from client to server. It covers essential concepts like DNS resolution, TCP and TLS handshakes, load balancing, and packet routing, all crucial for understanding how distributed systems communicate. Grasping these basics is vital for designing robust, performant, and secure software architectures.
Designing Robust Trust Mechanisms: Avoiding Permanent Lockouts in Distributed Systems
This article discusses critical considerations when implementing automated trust mechanisms, specifically extension ID pinning for a browser-to-local-server bridge. It highlights the architectural pitfalls of an unconditional, opaque pinning system that led to permanent user lockouts and incorrect diagnostics, advocating for visibility, clear undo mechanisms, and precise error reporting in distributed trust decisions.
The Perils of Retries in Distributed Systems
This article explores the critical, yet often overlooked, negative impacts of retries in distributed systems, particularly when not implemented carefully. It discusses how naive retry mechanisms can lead to cascading failures, system overloads, and unexpected behaviors, emphasizing the need for thoughtful design and strategic mitigation techniques.
A Roadmap for Learning System Design Fundamentals
This article outlines a comprehensive roadmap for aspiring system designers, emphasizing the transition from writing code to designing scalable, resilient systems. It highlights the core mindset required, focusing on understanding functional and non-functional requirements, anticipating failures, and making informed trade-offs. The roadmap stresses mastering foundational concepts like networking, client-server architecture, APIs, and databases before diving into advanced distributed systems.
Achieving Fixed IP Addresses for AWS ALBs using Global Accelerator
This article details a common solution for providing fixed IP addresses to clients when using AWS Application Load Balancers (ALBs), which inherently have dynamic IPs. It explains how to integrate AWS Global Accelerator with an ALB to expose static Anycast IPs, addressing the architectural challenge of client-side IP whitelisting without sacrificing ALB features or high availability. The solution uses Global Accelerator as a static entry point that routes traffic to an internal ALB.
The Evolving Role of Architecture in the AI Era of Software Development
This article argues that with the advent of AI code generation, understanding core software architecture principles becomes more critical than ever. It emphasizes that AI tools excel at optimizing existing solutions but lack the capacity for original problem-solving or deep business domain comprehension. Therefore, developers must master architectural concepts to effectively guide AI and design robust systems.
Azure API Management Standard v2: Zone Redundancy and Architectural Trade-offs
This article discusses the introduction of zone redundancy to Azure API Management's Standard v2 tier, enabling protection against datacenter-level failures at a lower cost than Premium tiers. It highlights the architectural implications, such as deployment constraints, SLA differences, and capacity guarantees, which are crucial considerations for designing highly available API infrastructures. Understanding these trade-offs is essential for selecting the appropriate API gateway tier for a robust system.
AWS Architecture Blog·3d agoTransitioning from Stateful to Stateless Protocols for Scalable Microservices on AWS
This article discusses the architectural shift from a stateful to a stateless protocol (MCP 2026-07-28) and its implications for building scalable and well-architected services on AWS. It highlights how statelessness simplifies horizontal scaling, improves observability, and enhances security by aligning with AWS Well-Architected Framework principles, especially for agentic AI applications. The move eliminates the need for sticky sessions and external session stores, making deployments more resilient and cost-effective.
Resiliency and Error Handling Strategies for LLM-Powered Applications
This article explores crucial strategies for building resilient LLM-powered applications, focusing on robust error handling, graceful degradation, and fault tolerance. It differentiates between technical and semantic failures inherent in LLM interactions and outlines architectural patterns like retries, timeouts, circuit breakers, and rate limiting to ensure application stability and a consistent user experience despite LLM unpredictability.
Achieving Idempotency in Distributed Systems to Prevent Duplicate Operations
This article explains why duplicate requests are an inherent challenge in distributed systems, especially due to network retries and timeouts. It details three primary architectural patterns for achieving idempotency: designing operations to be naturally idempotent, using idempotency keys for tracking and replaying requests, and leveraging conditional writes in the storage layer. The piece emphasizes that idempotency is a core aspect of reliable system design, not merely a bug fix.
Airbnb's Server-Driven Authentication Architecture
Airbnb redesigned its authentication architecture by shifting decision-making from client applications to a server-side policy engine. This server-driven approach enables dynamic adjustment of authentication flows, experimentation without client updates, and a significant reduction in client-side code, improving flexibility and user experience. The system centrally manages challenges based on user context, optimizing for success and offering fallback options.