Software Architecture

in practice

System Design #02: Understand key concepts

Written by

admin

in

System design is an essential skill for building scalable, maintainable, and performant software systems. It involves defining the architecture, components, and interactions within a system, ensuring that it meets both functional and non-functional requirements. One popular approach to building scalable applications is using microservices architecture.

System Design Keys Concept

1.1 Scalability

Scalability is the ability of a system to handle an increasing amount of load or users. A scalable system should grow without significant degradation in performance. Microservices help achieve scalability by distributing the load across smaller, independent services.

1.2 Availability and Reliability

Availability refers to the ability of a system to be operational and accessible when needed. Reliability is the system’s ability to perform as expected without failures. Redundancy and fault tolerance are key practices to ensure high availability and reliability.

1.3 Performance

Performance is about how fast and efficiently a system responds to requests. Optimizing performance can involve using caching, load balancing, and efficient database queries.

1.4 Maintainability

Maintainability is the ease with which a system can be updated, debugged, and modified over time. This is essential for long-term success and is supported by modular architecture like microservices.

Next we will dive into details,

1. Non-Functional Requirements (NFRs)

Non-functional requirements (NFRs) are the qualities or characteristics that the system must have. While functional requirements describe what the system should do, NFRs describe how the system should behave in various scenarios. These are often referred to as “quality attributes” or “ilities” (e.g., reliability, scalability, usability).

Common Types of Non-Functional Requirements:

  • Scalability: The ability of the system to handle an increasing amount of work or its potential to accommodate growth.
    • Example: The system should support up to 1 million concurrent users without degrading performance.
  • Performance: The system’s responsiveness and efficiency.
    • Example: The system should process a user login request within 2 seconds.
  • Availability: The degree to which the system is available for use, often expressed as a percentage of uptime.
    • Example: The system should be available 99.9% of the time.
  • Security: The system’s ability to protect against unauthorized access and data breaches.
    • Example: The application should encrypt sensitive data in transit using HTTPS and store passwords securely using hashing.
  • Reliability: The system’s ability to consistently perform as expected without failure.
    • Example: The application should be able to recover from failures without losing user data.
  • Usability: The ease with which users can interact with the system.
    • Example: The application should have an intuitive user interface that reduces the learning curve for new users.

Why NFRs Matter:

NFRs ensure that the system performs well in real-world conditions and meets user expectations for reliability, speed, and security.

2. Scale of the System

When designing a system, understanding scalability is critical to ensure that the system can grow as the demand increases. Scale refers to how well the system can handle an increase in load or the addition of new features.

Types of Scaling:

  • Vertical Scaling (Scaling Up): Adding more power (CPU, RAM, storage) to a single server.
    • Example: If the system needs more computational power to handle additional traffic, upgrading the existing server’s hardware is vertical scaling.
  • Horizontal Scaling (Scaling Out): Adding more machines to the system to distribute the load across multiple instances.
    • Example: Instead of upgrading a single server, you add multiple servers to handle requests in parallel (e.g., load balancing).

Scaling Considerations:

  • Elasticity: The ability of the system to dynamically scale up or down based on demand.
    • Example: An e-commerce website might automatically scale up during a sale or holiday season and scale down after the event is over.
  • Sharding: Splitting data into smaller, more manageable chunks across multiple databases or services to improve performance and scalability.
    • Example: An online social media platform may shard its user database across multiple servers based on user location or user ID range to distribute the load.

3. High-Level Design (HLD)

High-Level Design (HLD) is the architecture of the system. It outlines the major components, their interactions, and the flow of data. HLD provides a broader view of the system without getting into detailed implementation.

HLD Concepts:

  • Components and Subsystems: In HLD, you define the major components of the system. This could include microservices, databases, third-party APIs, etc.
    • Example: In an e-commerce platform, the HLD would include components like User Service, Product Service, Order Service, and Payment Gateway.
  • Data Flow and Communication: How data flows between components, whether through HTTP APIs, message queues, or other communication mechanisms.
    • Example: The Order Service may communicate with the Payment Gateway via an API to process a payment and with the Inventory Service to check product availability.
  • System Integration: Defines how different services and systems integrate and interact with each other.
    • Example: The Order Service might interact with the Shipping Service to send order details for delivery, and with the Notification Service to send a confirmation email.

Example of High-Level Design for an E-Commerce System:

  • User Service: Handles user registration, authentication, and profiles.
  • Product Service: Manages the catalog of products available for sale.
  • Order Service: Manages customer orders, processes payments, and tracks shipment.
  • Payment Gateway: A third-party service used to handle payments.
  • Notification Service: Sends emails and SMS messages to users.

4. Low-Level Design (LLD)

Low-Level Design (LLD) dives deeper into the individual components defined in the HLD. It specifies how each component or service will be implemented, with details about classes, methods, database schemas, and interfaces.

LLD Concepts:

  • Class Diagrams and Database Schemas: Define the structure of objects, their attributes, and methods in the system.
    • Example: For the Order Service, you would define classes like Order, Payment, and Shipment. Each class will have attributes like orderId, userId, paymentStatus, and methods like processPayment() or createShipment().
  • API Design: Detail the structure of the APIs, including endpoints, input/output parameters, status codes, and error handling.
    • Example: The POST /orders endpoint might accept a JSON payload like { "userId": 1, "productIds": [101, 102] }, and return a response { "orderId": 123, "status": "created" }.
  • Database Design: Specifies the database tables, relationships, and normalization.
    • Example: The Orders table might have columns like orderId, userId, status, and totalAmount. The Users table would store user details like userId, email, and passwordHash.
  • Algorithms and Logic: Detail the business logic or algorithms required for specific processes in the system.
    • Example: The Order Service might include an algorithm to check if items are in stock and reserve them before processing the payment.

Example of Low-Level Design for the Order Service:

  • Class Diagram for Order Service:
    • Order class with attributes orderId, userId, totalAmount.
    • Methods: createOrder(), calculateTotal(), applyDiscount().
  • Database Schema:
    • Orders table:
      • Columns: orderId, userId, status, createdAt, updatedAt.
    • OrderItems table:
      • Columns: orderItemId, orderId, productId, quantity, price.
  • API Design:
    • POST /orders: Create a new order.
    • Request: { "userId": 1, "productIds": [101, 102] }
    • Response: { "orderId": 123, "status": "created" }

Conclusion

In this tutorial, we covered the following essential concepts for system design:

  • Non-Functional Requirements (NFRs): Key aspects like scalability, performance, and security that define how a system should behave.
  • Scale of the System: Considerations for handling growth, including vertical and horizontal scaling, as well as sharding and elasticity.
  • High-Level Design (HLD): The architecture of the system, outlining major components and their interactions.
  • Low-Level Design (LLD): The detailed design of individual components, including class diagrams, API specifications, and database schemas.

Mastering these concepts is essential for building robust, scalable, and maintainable systems. As you advance in system design, you’ll learn to balance these requirements and create efficient, reliable software systems.

Comments

Leave a Reply

Your email address will not be published. Required fields are marked *

More posts