5.1 Mini Project Design & Implementation

Learning Goal:
• Apply all learned concepts to plan a real small system design.

Detailed Content:
• Team up: choose a simple topic (e.g., user sign-up, posting board)
• Analyze requirements and break them into layers and services
• Draft RESTful API endpoints
• Document the architecture: layered structure, flows, APIs
• Prepare a short presentation

5.1.1 Team Up: Choose a Simple Topic

After covering fundamental architecture patterns, design principles, and documentation strategies, the best way to solidify this knowledge is to apply it to a real mini project. The goal here is not to build a huge production system, but to practice translating ideas into a working, documented design that uses everything you’ve learned.

First, form a small team if possible—2 to 4 people work best for short sprints. Together, pick a simple yet realistic topic that everyone understands. Classic options include:

• A user sign-up and login module, with registration, authentication, and basic profile management.

• A simple posting board where users can create, read, update, and delete posts.

• A basic product catalog, if you want to add a slight e-commerce feel.

Choosing a small scope helps keep the focus on design quality, not endless feature creep.

5.1.2 Analyze Requirements and Break Them into Layers and Services

Once you’ve agreed on the topic, start by discussing the main functional requirements:

• Who are the users?

• What are the main use cases?

• What data needs to be stored?

Then map these requirements to a layered architecture. For example, in a posting board:

• Presentation Layer: handles HTTP requests (Controllers) and delivers JSON or HTML.

• Business Logic Layer: processes post creation rules, user validation, or simple moderation.

• Data Layer: stores users, posts, and comments in a database.

If you want to stretch a bit further, identify potential microservices. For instance, user management could be its own service, separate from the posting board logic.

5.1.3 Draft RESTful API Endpoints

Next, practice designing clean, RESTful endpoints for your mini project. For a posting board, you might have something like:

pgsql
POST   /api/posts         --> create a new post
GET    /api/posts         --> list all posts
GET    /api/posts/{id}    --> get a single post
PUT    /api/posts/{id}    --> update a post
DELETE /api/posts/{id}    --> delete a post

For user sign-up:

pgsql
POST   /api/users/signup  --> register new user
POST   /api/users/login   --> authenticate user
GET    /api/users/{id}    --> get user profile

Write these out as a simple table or a Swagger/OpenAPI draft if you want to practice a formal spec.

5.1.4 Document the Architecture: Layers, Flows, APIs

This step pulls together all the theory you’ve learned about architecture documentation. Draw a simple layered diagram that shows how requests flow from the Controller, through the Service layer, to the Repository or database.

If you’re feeling ambitious, sketch a C4-style mini diagram:

• Context: who uses the system.

• Container: the main app, database, maybe a separate auth service.

• Component: core modules like PostController, UserService, PostRepository.

Add your RESTful API design to the documentation. Explain what each endpoint does, what data it expects, and what response it returns.

5.1.5 Prepare a Short Presentation

Wrap it up by preparing a 5–10 minute presentation. Each team should explain:

• What they built.

• The key requirements and scope.

• The architecture design and why they structured it this way.

• The main API flows.

• Any lessons learned or challenges faced.

This final presentation isn’t just for practice—it helps you learn how to communicate your architecture, which is a critical skill for real projects.

Wrap-Up

This mini project is where theory meets practice. It proves that you can:

• Break down requirements logically.

• Structure a system into clean layers or services.

• Design clear REST APIs.

• Document the design so others can follow it.

• Present your ideas with confidence.