View source for Software Architecture vs Software Design

= Software Architecture vs Software Design =
The distinction between software design and software architecture is a classic point of debate, and definitions often vary depending on context, frameworks, or even individual experts.
The confusion often stems from overlapping terminology and differing interpretations in the industry.

1.	Software Architecture
* What it is: The strategic layer of a system. It defines high-level structural decisions, system-wide patterns, and constraints.
* Focus:
**	'''Non-functional requirements''': Scalability, security, fault tolerance, deployment topology.
** Components: What are the major parts (e.g., microservices, databases, APIs)?
** Interaction: How do they communicate (e.g., REST, event-driven)?
*	Metaphor: The city plan (zoning laws, transportation networks, power grids).
2.	Software Design
*	What it is: The tactical layer. It focuses on how individual components/modules work internally.
*	Focus:
** '''Functional requirements''': How a feature behaves (e.g., payment processing logic).
**	Implementation details: Algorithms, data structures, class hierarchies, design patterns.
** Code-level organization: SOLID principles, clean code practices.
* Metaphor: The blueprint for a single building (room layouts, electrical wiring, plumbing).
In short:
* Architecture = What the system is and how it’s organized.
* Design = How each part of the system works internally.
== Example ==
Let’s use the example of building an API Gateway middleware (e.g., handling authentication, rate limiting, request routing). Here’s how the distinction between architecture and design impacts the process—and what happens if ignored:
----

=== Software Architecture ===
Focus: High-level structure and system-wide decisions.
Key Architectural Decisions:
* Component Structure:
** Use a cloud-native, horizontally scalable architecture (e.g., Kubernetes pods).
** Separate components: authentication service, rate limiter, request router, logging service.
* Communication:
** REST APIs for external clients, gRPC for internal service communication.
* Non-functional Requirements:
** Scalability: Auto-scaling based on traffic.
** Security: OAuth 2.0 for authentication, TLS for encryption (The 'Transport Layer Security' cryptographic protocol secures data transmitted over networks).
** Fault Tolerance: Circuit breakers for downstream services.
* Metaphor: City planning—deciding where highways (APIs) go, zoning districts (microservices), and emergency services (fault tolerance).
----
=== Software Design ===
Focus: Implementation details of individual components.
Key Design Decisions:
* Rate Limiter Component:
** Algorithm: Token bucket vs. leaky bucket (choosing token bucket for burst tolerance).
** Data Structures: Redis for storing request counters (fast, distributed).
** Code Structure:
*** A RateLimiter class with methods like <code>checkLimit()</code> and <code>incrementCounter()</code>.
*** Using the Strategy pattern to allow swapping algorithms.
* Authentication Module:
** JWT validation logic, caching verified tokens to reduce latency.
** Error handling for expired/invalid tokens.
* Metaphor: Building blueprint—designing the plumbing (data flow), electrical wiring (API logic), and room layouts (class hierarchies).
----
By separating these concerns, the middleware is both strategically sound (architected for the future) and tactically robust (designed for efficiency). 🛠️
=== If the Distinction is Ignored ===
Scenario: A team starts coding without separating architecture and design.
Consequences:
* Chaotic Scalability:
** No auto-scaling plan → gateway crashes under traffic spikes.
* Security Gaps:
** Ad-hoc authentication logic → vulnerabilities like token leaks.
* Technical Debt:
** Tight coupling between rate limiter and router → impossible to update one without breaking the other.
* Performance Bottlenecks:
** Poor algorithm choice (e.g., naive rate limiting) → latency spikes.
* Inconsistent Patterns:
** Mixing REST and gRPC without a strategy → debugging nightmares.
Real-World Example:
A startup rushes to build an API Gateway without architectural planning. They hardcode rate limits in-memory (no Redis). At scale, the gateway fails because:
* Requests overwhelm the server (no auto-scaling).
* Rate limits reset on server restart (volatile storage).
* Authentication isn’t centralized, leading to security loopholes.