System Design vs. Software Architecture

Shilpa Prabhudesai

In software development, the terms system design and software architecture are often used interchangeably. However, while they are closely related, they are actually different. They serve different purposes and focus on different aspects of software systems.

System design deals with the specifics of how the system will be implemented, including components, interfaces, and technologies. Software architecture, on the other hand, focuses on the high-level structure and organization of a software system. Software architecture defines a software system’s components, relationships, and overall design principles.

For engineers, architects, project managers, and stakeholders involved in software systems development, understanding the exact differences between system design and software architecture is important to create robust and scalable software.

This article explains the system design and software architecture as well as the key differences between these two terms.

What is System Design?

System design is the process of defining components, interfaces, modules, and data for the system according to specified requirements. This can be considered a blueprint of the functioning system. It covers everything from data flow, load balancing, and database schemas to replication, caching, and scalability techniques. System design is the process of the analysis phase.

It covers the broader picture, including hardware, software, and network components. It deals with the overall architecture and how various parts of the system interact.

System Design Scope

The scope of system design includes:

• Infrastructure & Deployment: Focus is on how systems will be deployed, failure recovery, and scaling strategies.
• Load Distribution: Consists of load balancers, queue systems, and CDNs.
• Data Flow: Includes how data is passed between components, services, or layers.
• Resource Optimization: Deals with efficiency in memory usage, bandwidth, and latency.

Steps in System Design

System design involves the following steps:

• Requirement Analysis: Understand and document the system requirements. Read: How Requirement Reviews Improve Your Testing Strategy.
• Architectural Design: Design the system’s structure, including modules and how they interact.
• Database Design: Craft the schema, tables, relationships, and constraints for the database.
• User Interface Design: Define how users interact with the system through its interface. Read: UI Testing: What You Need to Know to Get Started.
• Component Level Design: Specify the functionality of each module in detail, including algorithms and data structures.

In general, system design:

• Ensures scalability and robustness.
• Creates systems capable of handling real-world traffic and failures.
• Balances trade-offs (e.g., availability vs. consistency).

System design employs key techniques like load balancing, sharding and partitioning, caching, database replication, and queue systems.

What is Software Architecture?

Software architecture focuses on the high-level structure and discipline, and how they relate. It defines the fundamental structures of a software system and provides a blueprint for the system and the project.

It deals with the big picture, such as overall structure and high-level design. It ensures that the system meets functional and non-functional requirements.

Software Architecture Scope

The scope of software architecture encompasses:

• Structural Decisions: Related to Monolith vs Microservices, layered architecture, and clean architecture. Read: Micro-frontends Automated Testing: Is It Possible?
• Component Interaction: Defines how modules and components communicate.
• Design Patterns: Uses patterns such as MVC, Observer, Singleton, and Factory for architectural purposes.
• Non-functional Requirements: Deals with security, maintainability, and performance.

Software Architecture Process

The following steps are carried out as part of the software architecture process:

1. Domain Modeling: Various entities and interactions are singled out in domain modeling.
2. Define Layers: Layers of abstraction, such as presentation, business, and data access, are defined.
3. Component Design: The next step includes various component designs like services, repositories, and utilities.
4. Pattern Implementation: Suitable design patterns are then chosen to design the software.
5. Technical Decisions: The last step is to decide on frameworks, platforms, and technologies for system implementation.

In general, software architecture:

• Defines maintainable and extendable codebases.
• Creates reusable and modular components.
• Enforces coding standards and development protocols.

Software architecture employs key techniques such as UML diagrams, dependency injection, code abstraction and encapsulation, and component/sequence diagrams.

System Design vs. Software Architecture

System design and software architecture have key differences, proving they are separate entities. Some of these key differences are listed in the following table:

In essence, software architecture provides the overall blueprint, while system design details the construction process. System design supersedes software architecture. It is an action where you design, implement, and deploy your software. Whereas, software architecture is the result of design and is the physical design.

System design can include more details than software architecture, though both terms are used interchangeably in non-formal discussions. However, both are crucial for building successful software systems.

Overlap in System Design and Software Architecture

Although system design and software architecture are different terms, their overlap is also significant.

Here are the overlapping areas for system design and software architecture:

• Microservices: System design and software architecture must define service boundaries and communication protocols like REST, gRPC, and data flow.
• Security: This is a common aspect that both should consider. System design must account for threat models, while architectural decisions affect how secure the system is.
• Fault Tolerance: Another area both system design and software architecture should pay attention to. System design must have a failover mechanism, while software architecture may support graceful degradation.
• Performance: If architecture is efficient, it can reduce system design complexity.

Real-World Example: Designing a Ride-Sharing App

Let us consider a real-world example to demonstrate system design and software architecture. Take an example of designing a ride-sharing app like Uber. Using this app, a user can book a ride, track the ride, conclude the ride, and pay the cost of the ride. Hence, this app will need a routing mechanism, GPS, payment processing, etc. From the discussions about system design and software architecture, the following are the details for this particular app:

From a System Design Perspective

System design for the ride-sharing app will have the following considerations:

• Load Balancing: Deals with routing ride requests to servers.
• Data Storage: Details about using databases, relational DB for users/rides, and NoSQL for GPS logs.
• Scalability: The app should be scaled such that it has geographically distributed services and databases.
• Resilience: System design has retry mechanisms if payment processing or messaging fails.

From a Software Architecture Perspective

• Domain Modeling: Entities for the app, like User, Driver, Ride, and Payment System.
• Services: Various services such as AuthenticationService, RideMatchingService, and PaymentService.
• Design Patterns: Use the Command pattern for ride state transitions like cancellation, update, etc.
• Code Modularity: The Codebase should be modularized so that there is a clear separation of concerns in the codebase.

As seen, system design deals with low-level implementation, while software architecture consists of the app’s high-level characteristics.

Future Trends in System Design and Software Architecture

With evolution and innovation in technology, system design and software architecture are sure to evolve. Some of the emerging trends in both fields are:

System Design Trends

• Cloud-Native Systems: System design for AWS, GCP, or Azure.
• Event-Driven Architecture: Use of pub/sub and message queues.
• Edge Computing: Data processing closer to the user’s geolocation for latency reduction.

Software Architecture Trends

• Microservices: Independently deployable modules to reduce complexity.
• Serverless: Event-driven code execution.
• Domain-Driven Design (DDD): Aligning software architecture with business domains.
• Hexagonal Architecture: Emphasizes the testability and adaptability of the system.

Challenges and Common Pitfalls

System Design Challenges

The following are the challenges usually faced in system design:

• Overengineering with unnecessary components stuffed into the system.
• Ignoring real-world constraints like network latency, especially in the case of cloud computing.
• Poor scalability planning leads to performance bottlenecks.

Software Architecture Challenges

Here are the challenges in software architecture:

• Overuse of design patterns makes systems harder to change.
• Lack of modularity causes tight coupling of components.
• Failing to consider future extensibility or tech debt.

Conclusion

System design and software architecture are complementary but not competitive. System design deals with an application’s performance, ensuring it works well under pressure. Software architecture ensures that an application is maintainable, modular, and elegant. Hence, both should go hand in hand. Focusing on one and ignoring the other will result in long-term failure.

Engineers must strive to understand both designing robust and scalable systems and designing well-architected systems.

“We spent so much time on maintenance when using Selenium, and we spend nearly zero time with maintenance using testRigor.”

Keith Powe VP Of Engineering - IDT