sia.hackernoon.com

For my final university project, I set out with an ambitious goal: to build a comprehensive bookstore management system in roughly 50 days. The challenge wasn’t just to create an e-commerce app, but to build a unified solution that serves online customers, in-store staff, and system administrators, all from a single, modern mobile application.This is the story of how I brought that idea to life using a full-stack .NET approach, combining a robust ASP.NET Core Web API backend with a beautiful, cross-platform .NET MAUI client. Along the way, I navigated architectural decisions, tackled real-world business logic, and learned invaluable lessons.

The Problem: A Disconnected Bookstore

Traditional bookstores often struggle with a digital divide. They might have a simple online store, but the in-store point-of-sale (POS) system, inventory management, and customer relationship data are often completely separate. This creates inefficiencies, from inaccurate stock levels to a disjointed customer experience.My goal was to solve this by creating a single, cohesive ecosystem where:

Customers could browse, buy, and manage their account online.
Staff could process in-store sales and manage inventory directly from a mobile device.
Admins could oversee the entire operation, from product management to sales reports, anytime, anywhere. Choosing .NET MAUI for the client and ASP.NET Core for the API was a natural fit. It allowed me to leverage my C# skills across the entire stack and build a truly native cross-platform application for Android, iOS, and Windows from a single codebase.

The Backend: Building a Solid Foundation with Clean Architecture

Before a single pixel was drawn on the UI, I knew the backend had to be robust, scalable, and testable. I chose to implement Clean Architecture, a design that enforces a strict separation of concerns and a clear dependency flow.

Here’s how it’s structured:

Domain Layer: The core of the system. It contains our business entities (Book, Order, User), enums, and repository interfaces. This layer has zero dependencies on any framework or database technology. It’s pure business.
Application Layer: This layer orchestrates the use cases. It defines the application’s logic through services (like IOrderService), handles DTOs, defines validation rules with FluentValidation, and contains AutoMapper profiles. It depends only on the Domain layer.
Infrastructure Layer: The “glue” to the outside world. It contains the implementation details, such as the ApplicationDbContext (using EF Core), repository implementations that talk to SQL Server, and services for interacting with external systems like Google Cloud Storage for image hosting. It implements the interfaces defined in the layers inside it.
Presentation Layer (API): The outermost layer, exposing our system to the world via RESTful endpoints and SignalR hubs (for future real-time features). It contains Controllers that handle HTTP requests and responses. This architecture wasn’t just theoretical; it paid off immediately. For example, using the Repository and Unit of Work patterns meant my application logic never directly knew it was talking to a SQL Server. I could swap out the database technology in the future without touching the core business rules.

The Frontend: A Modern, Cross-Platform Experience with .NET MAUI

With a solid API in place, it was time to build the client. The goal was a modern, intuitive, and performant app. I leveraged the MVVM (Model-View-ViewModel) pattern to achieve a clean separation between the UI (View) and the application logic (ViewModel).

Key components of the MAUI architecture include:

.NET MAUI Shell: I used Shell to create a consistent and powerful navigation structure, including a flyout menu. The best part? I could dynamically show or hide menu items (like “Admin Panel”) based on the user’s role, which was determined after they logged in.
MVVM Toolkit: This library was a lifesaver. Features like [ObservableProperty] and [RelayCommand] dramatically reduced boilerplate code in my ViewModels, allowing me to focus on the application’s state and logic.
Refit: Instead of manually crafting HttpClient requests, I used Refit to create type-safe, declarative API clients. I just define an interface, and Refit handles the implementation.
Centralized State Management: An AuthService singleton manages the login state, JWT token (stored in SecureStorage), and current user information, making it accessible throughout the app. An AuthHeaderHandler automatically attaches the token to all relevant API requests.

Data Visualization: To provide real value for administrators, I integrated Microcharts.Maui to create simple yet effective charts for reports like revenue trends and best-selling books, turning raw data into actionable insights directly on their mobile device.

Key Features

The final application successfully supports three distinct user roles with tailored experiences:

Customer Flow: From browsing products and adding to the cart, to a multi-step checkout process with address selection, and viewing order history.
Staff Flow: Enables in-store operations, such as creating orders for walk-in customers and managing inventory by creating stock receipts directly from the app.
Admin Flow: Provides a comprehensive overview via a dashboard and detailed reports. Admins can manage the entire catalog of products, categories, authors, promotions, and users.

The application features over 70 REST standard API endpoints, fully meeting the essential requirements for an effective bookstore management system.

Challenges and Lessons Learned

No project is without its challenges. My biggest learning moments came from:

Tackling Asynchronous Complexity: Juggling multiple async calls (e.g., loading data for the checkout page) and updating the UI safely was a major hurdle. I learned the hard way about the importance of using MainThread.BeginInvokeOnMainThread and creating robust state management with IsBusy flags to provide a smooth user experience.
MAUI Shell Navigation Quirks: I encountered “Ambiguous Route” exceptions when using relative navigation (..). The lesson learned was to be very explicit with my routes, often using absolute navigation (//HomePage/CategoriesPage/…) to ensure clarity and avoid confusion in the navigation stack.
The “Why” of Clean Architecture: Initially, the architecture felt like overkill. But when I had to modify the database schema or add new business rules (like handling in-store orders), I truly appreciated it. I could make changes in one layer with minimal impact on the others, which saved me a massive amount of time and prevented new bugs.

Conclusion and Next Steps

In just over 100 days, I successfully built a full-stack, cross-platform application that solves a real-world problem for bookstores. This journey has solidified my understanding of modern .NET development, from designing robust, testable backends with Clean Architecture to building beautiful, responsive frontends with .NET MAUI and MVVM.While the core functionality is complete, the journey isn’t over. The next steps would be to implement a comprehensive automated testing suite (Unit & Integration Tests), integrate a real payment gateway, and set up a CI/CD pipeline for deployment.

You can find the complete source code on my GitHub:

Backend API (ASP.NET Core): https://github.com/hoangnguyenn26/BookStoreManagement-API