Software architecture and design project_answer.docx

To create a "Dormitory Management System" using the provided software architecture and design
document template, you can follow the structure outlined in the template. Below is a sample outline
filled with relevant content for each section:
1. INTRODUCTION
1.1. Purpose
This software design document describes the architecture and system design of the Dormitory
Management System (DMS). The purpose of this document is to provide a comprehensive overview of
the system's design, functionality, and architecture for stakeholders and developers.
1.2. Scope
The Dormitory Management System aims to streamline the management of dormitory facilities,
including student registration, room allocation, billing, and maintenance requests. The system will
enhance operational efficiency and improve the living experience for students.
1.3. Overview
This document is organized into several sections, including system overview, quality attributes, system
architecture, data design, component design, and design patterns. Each section provides detailed
information about the system's design and implementation.
1.4. Intended Users
The intended users of this document include software developers, project managers, system architects,
and stakeholders involved in the development and maintenance of the Dormitory Management System.
1.5. Definitions and Acronyms
 DMS: Dormitory Management System
 SRS: Software Requirements Specification
 UI: User Interface
 DB: Database
2. SYSTEM OVERVIEW AND CONSTRAINTS
2.1. System Overview
The Dormitory Management System will provide functionalities such as student registration, room
assignment, billing management, and maintenance tracking. The system will be web-based, allowing
users to access it from any device with internet connectivity.
2.2. Constraints
 The system must comply with data protection regulations (e.g., GDPR).
 The development will be constrained by a budget and timeline.

 The system should be compatible with existing university IT infrastructure.
3. QUALITY ATTRIBUTE SCENARIOS AND TACTIC SELECTION
3.1. Quality Attribute Scenarios
 Performance: The system should handle up to 500 concurrent users without significant
performance degradation.
 Security: User data must be encrypted and secure from unauthorized access.
 Usability: The system should have an intuitive UI that allows users to complete tasks within
three clicks.
 Scalability: The system should be able to accommodate an increase in users and data without
requiring a complete redesign.
 Availability: The system should have 99.9% uptime.
3.2. Tactic Selection
| Quality Attribute | Design Concern | Tactic Selected | |-------------------|----------------|------------------| |
Performance | Response Time | Load Balancing | | Security | Data Protection| Encryption | | Usability |
User Experience| User-Centered Design | | Scalability | System Growth | Modular Architecture | |
Availability | System Downtime| Redundancy |
4. SYSTEM ARCHITECTURE
4.1. Architectural Design
The system will be decomposed into several subsystems: User Management, Room Management, Billing
System, and Maintenance Management. Each subsystem will have defined responsibilities and will
interact through well-defined interfaces.
4.2. Module View
 User Management: Handles student registration and authentication.
 Room Management: Manages room assignments and availability.
 Billing System: Processes payments and generates invoices.
 Maintenance Management: Tracks maintenance requests and status.
4.3. Component and Connector View
The system will utilize a client-server architecture where the client interacts with the server via RESTful
APIs. Sequence diagrams will illustrate the interactions between components during user registration
and room allocation.

4.4. Allocation View
The deployment model will include a web server, application server, and database server. The web server
will host the UI, while the application server will handle business logic and database interactions.
4.5. Design Rationale
The chosen architecture allows for modular development, making it easier to maintain and scale.
Alternatives considered included a monolithic architecture, which was rejected due to potential
scalability issues.
5. DATA DESIGN
5.1. Data Description
The system will utilize a relational database to store information about students, rooms, billing records,
and maintenance requests. Key entities include Student, Room, Billing, and Maintenance Request.
5.2. Data Dictionary
 Student: ID, Name, Email, Phone, Room ID
 Room: ID, Room Number, Capacity, Status
 Billing: ID, Student ID, Amount, Due Date
 Maintenance Request: ID, Room ID, Description, Status
6. COMPONENT DESIGN
Each component will be designed to fulfill its specific responsibilities. For example, the User
Management component will include functions for registering users, authenticating users, and retrieving
user profiles.
////////////////////////////////////////////////////////////////////////////
Here’s a structured example for a Dormitory Management System (DMS) software architecture and
design document. This serves as a guideline you can customize based on your specific requirements.
Dormitory Management System (DMS)
Software Architecture and Design Document

1. Introduction
1.1 Purpose
The Dormitory Management System (DMS) is designed to simplify and automate dormitory-related
operations. The system aims to manage resident information, allocate rooms, track payments, and
handle maintenance requests efficiently.
1.2 Scope
DMS is intended for use by dormitory administrators, residents, and staff. It supports tasks such as
resident registration, room assignments, billing, and issue tracking. The system includes a web-based
interface for administrators and a mobile application for residents.
1.3 Definitions, Acronyms, and Abbreviations
 CRUD: Create, Read, Update, Delete
1.4 References
 Unified Modeling Language (UML) Diagrams
 IEEE Software Architecture Standard (ISO/IEC/IEEE 42010)
1.5 Overview
This document describes the architecture and design decisions for the DMS. It includes system
architecture, module design, and data models.
2. System Overview
The DMS is a multi-user system with three primary roles:
1. Administrator: Manages resident information, room assignments, and billing.
2. Resident: Views room details, payment status, and raises maintenance requests.
3. Maintenance Staff: Handles requests raised by residents.
The system has three core modules:
1. Resident Management
2. Room Allocation
3. Maintenance and Billing Management

3. Architectural Design
3.1 System Architecture
The architecture is a three-tier design:
1. Presentation Layer: Web UI for administrators, mobile app for residents.
2. Application Layer: Handles business logic, implemented in Java/Spring Boot.
3. Database Layer: Stores all resident, room, and billing data using MySQL.
3.2 Architectural Patterns
 Model-View-Controller (MVC) for separation of concerns.
 RESTful API for communication between the frontend and backend.
4. Module Design
4.1 Resident Management Module
Functionality:
 Add, update, and delete resident details.
 View a resident's profile.
Design:
 Input: Resident name, contact details, ID proof.
 Output: Confirmation of successful operation or error message.
API Endpoints:
 POST /residents: Add a new resident.
 GET /residents/{id}: Get resident details.
 PUT /residents/{id}: Update resident details.
4.2 Room Allocation Module
Functionality:
 Allocate or deallocate rooms.
 View room availability.
Design:

 Input: Resident ID, room number.
 Output: Updated room status.
API Endpoints:
 POST /rooms/allocate: Allocate a room.
 GET /rooms/available: Fetch available rooms.
4.3 Maintenance and Billing Management Module
Functionality:
 Submit maintenance requests.
 Generate invoices for residents.
Design:
 Input: Resident ID, issue description, or billing details.
 Output: Request status or invoice PDF.
API Endpoints:
 POST /maintenance: Submit maintenance requests.
 GET /billing/{id}: Fetch payment history.
5. Data Design
5.1 Entity-Relationship (ER) Diagram
Key entities:
 Residents: Stores resident details.
 Rooms: Stores room details and statuses.
 Maintenance Requests: Tracks maintenance issues.
 Billing: Stores payment details.
5.2 Database Tables
Residents Table:
Field Type Description
ResidentID INT (PK) Unique ID of resident
Name VARCHAR(100) Name of the resident

PhoneNumber VARCHAR(15) Contact number
Rooms Table:
RoomID INT (PK) Unique ID of room
Capacity INT Number of occupants
Availability BOOLEAN Room availability
6. User Interface Design
6.1 Administrator UI
 Dashboard: Displays total residents, available rooms, and pending requests.
 Forms: For adding or updating resident/room details.
6.2 Resident UI
 Mobile App:
o Home screen showing room details and payment status.
o Form for submitting maintenance requests.
6.3 Wireframes
 Web Admin Panel: Room allocation form and billing dashboard.
 Mobile App: Simplified navigation for residents.
7. Implementation Strategy
 Frontend: React.js for the web app and Kotlin for the mobile app.
 Backend: Spring Boot for APIs and business logic.
 Database: MySQL for relational data and Redis for caching.
8. Testing Plan
8.1 Unit Testing

 Test CRUD operations for residents, rooms, and maintenance requests.
8.2 Integration Testing
 Ensure APIs communicate correctly with the frontend and database.
8.3 User Acceptance Testing
 Verify with administrators and residents for usability.
9. Deployment Strategy
 Environment: Host backend on AWS EC2 and frontend on AWS S3.
 Database: MySQL hosted on AWS RDS.
10. Maintenance Plan
 Regular database backups.
 Monitor API performance using tools like Prometheus and Grafana.
 Implement bug fixes and feature updates quarterly.
///////////////////////////////////////////////////////////////
Dormitory Management System (DMS)
Software Architecture and Design Document
1. Introduction
1.1 Purpose
The Dormitory Management System (DMS) is designed to simplify and automate dormitory-related
operations. The system aims to manage resident information, allocate rooms, track payments, and
handle maintenance requests efficiently.
1.2 Scope
DMS is intended for use by dormitory administrators, residents, and staff. It supports tasks such as
resident registration, room assignments, billing, and issue tracking. The system includes a web-based
interface for administrators and a mobile application for residents.
1.3 Definitions, Acronyms, and Abbreviations

 CRUD: Create, Read, Update, Delete
1.4 References
 Unified Modeling Language (UML) Diagrams
 IEEE Software Architecture Standard (ISO/IEC/IEEE 42010)
1.5 Overview
This document describes the architecture and design decisions for the DMS. It includes system
architecture, module design, and data models.
2. System Overview
The DMS is a multi-user system with three primary roles:
1. Administrator: Manages resident information, room assignments, and billing.
2. Resident: Views room details, payment status, and raises maintenance requests.
3. Maintenance Staff: Handles requests raised by residents.
The system has three core modules:
1. Resident Management
2. Room Allocation
3. Maintenance and Billing Management
3. Architectural Design
3.1 System Architecture
The architecture is a three-tier design:
1. Presentation Layer: Web UI for administrators, mobile app for residents.
2. Application Layer: Handles business logic, implemented in Java/Spring Boot.
3. Database Layer: Stores all resident, room, and billing data using MySQL.
3.2 Architectural Patterns
 Model-View-Controller (MVC) for separation of concerns.
 RESTful API for communication between the frontend and backend.

4. Module Design
4.1 Resident Management Module
Functionality:
 Add, update, and delete resident details.
 View a resident's profile.
Design:
 Input: Resident name, contact details, ID proof.
 Output: Confirmation of successful operation or error message.
API Endpoints:
 POST /residents: Add a new resident.
 GET /residents/{id}: Get resident details.
 PUT /residents/{id}: Update resident details.
4.2 Room Allocation Module
Functionality:
 Allocate or deallocate rooms.
 View room availability.
Design:
 Input: Resident ID, room number.
 Output: Updated room status.
API Endpoints:
 POST /rooms/allocate: Allocate a room.
 GET /rooms/available: Fetch available rooms.
4.3 Maintenance and Billing Management Module
Functionality:
 Submit maintenance requests.
 Generate invoices for residents.

Design:
 Input: Resident ID, issue description, or billing details.
 Output: Request status or invoice PDF.
API Endpoints:
 POST /maintenance: Submit maintenance requests.
 GET /billing/{id}: Fetch payment history.
5. Data Design
5.1 Entity-Relationship (ER) Diagram
Key entities:
 Residents: Stores resident details.
 Rooms: Stores room details and statuses.
 Maintenance Requests: Tracks maintenance issues.
 Billing: Stores payment details.
5.2 Database Tables
Residents Table:
ResidentID INT (PK) Unique ID of resident
Name VARCHAR(100) Name of the resident
PhoneNumber VARCHAR(15) Contact number
Rooms Table:
RoomID INT (PK) Unique ID of room
Capacity INT Number of occupants
Availability BOOLEAN Room availability
6. User Interface Design
6.1 Administrator UI

 Dashboard: Displays total residents, available rooms, and pending requests.
 Forms: For adding or updating resident/room details.
6.2 Resident UI
 Mobile App:
o Home screen showing room details and payment status.
o Form for submitting maintenance requests.
6.3 Wireframes
 Web Admin Panel: Room allocation form and billing dashboard.
 Mobile App: Simplified navigation for residents.
7. Implementation Strategy
 Frontend: React.js for the web app and Kotlin for the mobile app.
 Backend: Spring Boot for APIs and business logic.
 Database: MySQL for relational data and Redis for caching.
8. Testing Plan
8.1 Unit Testing
 Test CRUD operations for residents, rooms, and maintenance requests.
8.2 Integration Testing
 Ensure APIs communicate correctly with the frontend and database.
8.3 User Acceptance Testing
 Verify with administrators and residents for usability.
9. Deployment Strategy
 Environment: Host backend on AWS EC2 and frontend on AWS S3.
 Database: MySQL hosted on AWS RDS.
10. Maintenance Plan
 Regular database backups.

 Monitor API performance using tools like Prometheus and Grafana.
 Implement bug fixes and feature updates quarterly.

Software architecture and design project_answer.docx

More Related Content

Similar to Software architecture and design project_answer.docx (20)

Recently uploaded (20)

Software architecture and design project_answer.docx