Skip to main content

Introduction to system architecture

The RaiseHub system architecture is designed to be scalable, maintainable, and efficient, supporting a crowdfunding platform that allows users to create and fund projects. This section provides a detailed breakdown of the architecture and its key components, from high-level context to specific technical implementations.

Purpose of This Section​

The System Architecture documentation serves the following purposes:

  1. Understand the System:
    Offer a comprehensive view of how the system is structured and how various parts interact. This documentation is useful for developers, architects, and stakeholders looking to understand how RaiseHub functions.

  2. Clarify Responsibilities:
    Clearly outline the role of each component within the system, including front-end, back-end, database, and external systems, and how they collaborate to provide the platform's core functionalities.

  3. Enable Future Enhancements:
    By documenting the current system architecture, future development efforts are supported, allowing new features or changes to be introduced without affecting the stability of the system.

Architectural Model​

The RaiseHub system follows a layered architecture to promote separation of concerns and maintainability. At a high level, the system consists of the following layers:

  • Presentation Layer: Handled by a Single-Page Application (SPA) built with React, offering users an interactive interface for project creation, funding, and browsing.
  • Business Logic Layer: Managed by a back-end API built with Spring Boot, responsible for processing user requests, managing business rules, and interacting with data services.
  • Data Access Layer: A relational database (MySQL) that stores all system data, including users, projects, and transactions.

Key Features of the Architecture​

  1. Scalability:
    The system is designed to handle a growing number of users and projects by separating the presentation, business logic, and data layers. This allows each layer to scale independently based on traffic and usage patterns.

  2. Modularity:
    Each component within the system is responsible for a specific task (e.g., user management, project creation, payment processing). This modular design makes it easier to update or replace components without disrupting the entire system.

  3. Maintainability:
    The architecture is based on clear, well-defined responsibilities for each component. This reduces the complexity of debugging and testing, ensuring long-term maintainability.

  4. Security:
    By adhering to security best practices, such as user authentication and data validation, RaiseHub ensures that user data is protected.

System Architecture Diagrams​

Throughout this section, you will find a series of C4 diagrams that explain the architecture at different levels of detail:

  1. Context Diagram:
    Provides an overview of the system and its interactions with external actors (e.g., users, admins, third-party services).

  2. Container Diagram:
    Breaks down the system into its core containers, including the front-end, back-end, database, and external systems.

  3. Component Diagram:
    Delves into the internal structure of key containers, such as the API Application, and highlights how components such as controllers, services, and repositories interact.

  4. Code Diagram (not included):
    Offers a closer look at the source code structure for specific components when necessary, useful for developers looking to contribute to the system. This diagram is not included in this section as it is not necessary for a system overview.

Conclusion​

This architecture overview is designed to help both technical and non-technical stakeholders understand how RaiseHub operates from a high-level perspective. As you dive deeper into each section, you will gain a better understanding of how the system’s components are implemented and how they work together to deliver the platform’s functionalities.

For more detailed technical documentation, refer to the sections on individual components, software principles, and the application flow across the system.