System Design
System Design Overview
• System design is the stage in the software
development life cycle where the architecture and
structure of a system are planned and detailed. It’s a
critical phase that sets the foundation for the actual
coding and implementation. A well-designed system will
meet the functional and non-functional requirements,
while ensuring scalability, reliability, and maintainability.
Key Aspects of System Design
• High-Level Design (HLD): High-level design focuses on
defining the architecture and framework of the entire
system. It is more abstract and gives an overview of how
the system works and its components.
• Components:
• Architecture: Defines the overall architecture of the system, including
components and their interactions.
• Interface Design: Describes how the system will interact with external
systems and users.
• Technologies: Decides on the technology stack (e.g., programming
languages, frameworks, databases).
• Output: The high-level design results in diagrams such as
Component Diagrams and System Architecture Diagrams.
Key Aspects of System Design
• Low-Level Design (LLD): Low-level design focuses on the detailed
design of individual components, their interfaces, and their logic. It is a
more granular level of design that specifies how the system's components
will work together.
• Components:
• Class Diagrams: Specifies object-oriented structures.
• Sequence Diagram: Show detailed behaviour or structure within specific
scenarios or components.
• Data Flow Diagrams (DFD): Describes how data moves through the system.
• Entity-Relationship Diagrams (ERD): Visualizes the relationships between
entities in a database.
• Pseudocode: Describes algorithms or the flow of logic in detail.
• API Design: Outlines the design and specifications of the system’s APIs.
• Module Design: Specifies how individual modules or components will interact and
function.
High Level Design - System
Architecture
• System Architecture refers to the conceptual model
that defines the structure, behaviour, and essential
properties of a system. It serves as a blueprint for both
system design and implementation, ensuring all
components and subsystems work cohesively to
achieve the system’s objectives. System architecture
encompasses the system's components, their
interactions, and the technologies used to implement
them.
System Architecture Diagrams
•A System Architecture
Diagram is a high-level graphical
representation of a system's
components and their
interactions. It helps
stakeholders, designers, and
developers visualize the structure
and relationships within a system.
These diagrams are critical for
planning, documenting, and
communicating system design
effectively.
Types of System Architectures
• Monolithic Architecture: Everything is built as a
single, tightly integrated unit.
• Client-Server Architecture: The system consists of
clients that request services and servers that provide
them.
• Three-Tier Architecture: The system is divided into
three layers: presentation, logic, and data.
• Microservices Architecture: A system is made up of
small, independent services that handle specific tasks.
Components of System Architecture
Component Description
Hardware Physical components such as servers, networks, and devices.
Software Programs and applications that provide system functionality.
Communication channels between components (LAN, WAN,
Networking
internet).
Data Management Databases and storage systems to handle data.
Points of interaction between components or with external
Interfaces
systems.
Security
Protect data, communications, and system access.
Mechanisms
Class Diagram
• A Class Diagram is a static structure diagram that
shows the structure of a system by displaying its
classes, their attributes, methods, and the
relationships between the classes.
• Purpose: Used to model the structure of objects
within a system and their interactions.
• Key Components:
• Classes: Represented by rectangles divided into three parts:
class name, attributes, and methods.
• Associations: Lines connecting classes to represent
relationships like inheritance, aggregation, and composition.
Key Relationships in UML Class
Diagrams
• Inheritance (Generalization): Represents a parent-child
relationship. Example: Dog inherits from Animal.
• Aggregation: Represents a "whole-part" relationship where parts
can exist independently. Example: Department has Employees.
• Composition: Stronger "whole-part" relationship where parts cannot
exist independently. Example: Car has an Engine.
• Association: Generic connection between two classes. Example:
Customer places an Order.
• Dependency: One class depends on another but does not own it.
Example: Car depends on Fuel.
• Realization: Represents a relationship between an interface and a
class implementing it. Example: Car realizes the Vehicle interface.
Class Diagram
Class Diagram - Order
Sequence diagram
• A dynamic diagram that models the sequence of
interactions between objects or components in a system
during a specific process or scenario.
• Purpose: Helps visualize message exchanges over time,
focusing on the order of operations and object behaviour.
• Key Components:
• Objects/Actors: Represented by rectangles at the top of the
diagram.
• Messages: Arrows between objects showing method calls or data
exchanges.
• Lifelines: Vertical dashed lines that represent the existence of an
object over time.
Sequence diagram – Order
Processing
Entity-Relationship Diagram (ERD)
• An ERD is a data model that represents the entities
(objects, concepts) in a system and their relationships.
• Purpose: Helps design the database schema and visualize
the structure of data and how different entities are
related.
• Key Components:
• Entities: Represented by rectangles, such as Customer, Order,
Product.
• Relationships: Represented by diamonds or lines connecting
entities, such as Customer places Order.
• Attributes: Represented by ovals, which are the properties of an
entity (e.g., Customer Name, Order Date).
ERD Relationship
• Entity-Relationship Diagrams (ERDs) represent data and their
relationships in a database. Here are the main types of
relationships in ERDs:
• One-to-One (1:1) Relationship: One entity is associated
with only one instance of another entity.
• One-to-Many (1:N) Relationship: One entity is associated
with many instances of another entity.
• Many-to-Many (M:N) Relationship: Many instances of one
entity are associated with many instances of another entity.
• Self-Referencing Relationship: An entity is related to
itself. i.g, An Employee supervises other Employees.
ERD Diagram
Design Principles
• Modularity: The system should be divided into smaller, self-contained
modules to enhance reusability and maintainability.
• Scalability: The system should be able to handle increased loads by
scaling horizontally (adding more machines) or vertically (upgrading
existing machines).
• Maintainability: The design should allow for easy updates, bug fixes, and
improvements over time.
• Performance: Ensure the system performs well under various conditions,
including response times, data processing speeds, and user load.
• Security: Design should include measures for protecting data and system
resources from unauthorized access, attacks, or breaches.
• Fault Tolerance: The system should be able to continue functioning
correctly even in the event of component failure.
System Design Methodologies
• Top-Down Design: The design process starts from the
top level (overall system) and breaks down into smaller,
more manageable components.
• Bottom-Up Design: Focuses on developing the system
from smaller modules first, and then combining them to
form a larger system.
• Incremental Design: The system is designed and
developed in iterations or increments, adding features
and functionality over time.
System Design Process
• Requirement Analysis: Before starting system design, gather and
analyze the system’s requirements (both functional and non-functional).
Understand the problems the system will solve and the user needs.
• Example: If the system needs to handle 10,000 concurrent users, this would affect
the design in terms of scalability and performance.
• Architectural Design: Define the system’s overall structure and the
interaction between components (e.g., client-server, microservices, or
monolithic).
• Example: In a client-server design, the server is responsible for handling business
logic, while the client handles the user interface.
• Detailed Design: Break down the architecture into detailed components
such as modules, APIs, and databases. Specify how each module will
function and how data will flow.
• Example: In an e-commerce system, the payment module interacts with external
payment gateways (e.g., PayPal or Stripe) for transaction processing.
System Design Process
• Design Review: Perform reviews to ensure that the design satisfies all
requirements, including scalability, security, performance, and usability.
Involve stakeholders to verify the alignment with business needs.
• Prototyping: Create prototypes of critical components (e.g., UI screens
or payment flow) to validate the design early in the process. This helps
identify issues early and allows for iterative improvements.
• Documentation: Document the design thoroughly, including
architectural diagrams, module details, and data flow. This serves as a
reference for developers during the implementation phase.
• Implementation & Testing: Once the design is completed and
approved, developers begin coding based on the design specifications.
Testing ensures that the system meets its design goals and performs as
expected.
Conclusion
• System design is a vital process that defines how a
system will be built and how it will function. It ensures
that both technical and business requirements are met
and that the system can be developed efficiently,
scalably, and securely. The combination of high-level
architecture design, detailed component design, and
adherence to design principles ensures that the final
system is robust, maintainable, and meets user
expectations. Proper system design helps mitigate risks
early in the development process and reduces the
likelihood of costly rework during implementation.