Forem: Gustavo felix

[Boost]

Gustavo felix — Sat, 06 Dec 2025 21:17:29 +0000

Gustavo felix

Dec 6 '25

From Tutorials to a Real Banking Platform: Inside Alvor Bank (.NET 10 + Angular 21 Nx Monorepo)

#dotnet #angular #microservices #eventdriven

Comments

3 min read

From Tutorials to a Real Banking Platform: Inside Alvor Bank (.NET 10 + Angular 21 Nx Monorepo)

Gustavo felix — Sat, 06 Dec 2025 21:16:31 +0000

Most of us start our careers building small tutorial projects:

todo apps
basic CRUD APIs
simple dashboards

They’re great for learning syntax… but they don’t prepare you for production systems with:

authentication & authorization
domains like Customers, Accounts, Transactions
CI/CD pipelines
test coverage & quality gates
microservices boundaries
real frontend architecture

So I decided to build something closer to what I see in real work:

A full digital banking platform called Alvor Bank, using .NET 10 and Angular 21.

In this post I’m sharing a quick architecture & quality overview of the system. The same slides are what I use in my roadmap/slide deck.

You can use this as a reference for your own full-stack projects.

1. High-Level Architecture

At a high level, Alvor Bank is split into:

API Gateway (YARP)
IAM Service (auth, tenants, roles)
Customer Service
Account Service
Transaction Service
Notification Service
Angular frontends for Admin and Branch/Cashier portals
RabbitMQ for events
PostgreSQL databases per microservice

The idea is simple:

IAM owns identity & access
CustomerService owns customer data
AccountService owns account rules and balances
TransactionService owns money movement
NotificationService reacts to events and communicates with users

Each service changes for its own reasons, which keeps the boundaries clean.

2. Solution Structure & Clean Architecture

On the backend, each microservice follows the same structure:

*.Domain – entities, value objects, domain services
*.Application – use cases, DTOs, interfaces
*.Infrastructure – EF Core, repositories, external integrations
*.API – Minimal API / controllers, DI wiring, input/output models

This makes it easy to:

onboard new developers
navigate the codebase
apply the same patterns across services

Example slide (VS solution explorer):

Even though each service has its own solution/projects, the structure is consistent, which pays off a lot as the system grows.

3. Test Coverage as a Quality Gate

One thing I didn’t want was “we’ll add tests later” (a lie we’ve all told ourselves).

So from the beginning:

there are unit tests for domain logic
integration tests for API + database
test projects are first-class citizens in the solution
the CI pipeline fails if coverage drops below a threshold

Example slide for this section:

This shifts tests from “nice to have” to an actual quality gate.

4. CI/CD Pipeline (GitHub Actions)

Every pull request triggers an automated pipeline that:

Restores & builds the backend (all microservices)
Restores & builds the frontend (Angular Nx)
Runs all tests (unit + integration)
Runs linters (backend + frontend)
Builds Docker images (where applicable)

In later stages, this can be extended to:

push images to a registry
deploy to dev/staging environments

Example slide for CI/CD:

This way, “it works on my machine” is no longer the standard.

5. Security & IAM

For a banking system, security isn’t optional.

Alvor Bank uses:

a dedicated IAM Service (based on ASP.NET Identity)
JWT for authentication
roles & claims for authorization
tenant-aware flows for multi-tenant scenarios
secure APIs behind the gateway

Instead of sprinkling [Authorize] everywhere randomly, the goal is to design clear boundaries:

what each role can do
where trust is enforced

6. Final Scope: What the System Actually Does

Alvor Bank is not just architecture for architecture’s sake.

The planned scope includes:

Customer onboarding
Creating and managing accounts
Deposits, withdrawals, transfers
Viewing balances and transaction history
Admin features and branch/cashier workflows
Notifications triggered by business events
Angular portals integrated with all backend services

Why I’m Building This (and Where to Follow Along)

I’ve seen a lot of content about:

microservices
Angular
CI/CD
Docker

…but very little that connects everything into one real, end-to-end system.

So I’m building Alvor Bank in public and documenting the full journey in an early-access book:

📘 Modern Full-Stack Banking Microservices

A step-by-step guide to building a digital banking platform with .NET, Angular, microservices, Docker, RabbitMQ, PostgreSQL, and GitHub Actions CI/CD.

👉 You can check it out here:

The Book

New chapters and updates are being added as the system evolves.

If you’ve built something similar (fintech, banking, event-driven systems), I’d love to hear:

What’s one non-negotiable quality gate you enforce in your pipelines?

How I Designed a Full-Stack Banking Microservices Architecture Using .NET 9 + Angular Nx

Gustavo felix — Sat, 29 Nov 2025 20:51:47 +0000

For the last few years, I’ve been working on enterprise systems in banking, logistics, and fintech. One thing I realized is that most tutorials don’t come close to what a real production environment looks like.

So I decided to build and share a real digital banking platform, using the same technologies used by modern financial systems:

.NET 9 Microservices
Angular 19 in an Nx Monorepo
Clean Architecture + DDD
PostgreSQL + EF Core
RabbitMQ (Event-Driven Architecture)
Docker & Docker Compose
GitHub Actions CI/CD
YARP API Gateway

Below is the high-level architecture:

Why I Built This
Most developers learn microservices, Angular, and CI/CD separately.
But in real life, they all work together.

A real banking system needs:

onboarding
accounts
transactions
auditing
security
notifications
customer portal
admin/back-office portal
This requires a full-stack architecture, not just backend or frontend tutorials.

High-Level Architecture Overview

Here’s a breakdown of the system:

Frontend (Angular + Nx)

Nx Monorepo
Customer Portal
Branch/Cashier Portal
Shared UI libraries
Signals/NgRx for state

Backend (.NET 9 Microservices)

AccountService
CustomerService
TransactionService
NotificationService
IAMService (Identity, JWT)

Communication

REST via YARP API Gateway
Events via RabbitMQ

Infrastructure

PostgreSQL per microservice
Dockerized environment
GitHub Actions for CI: build → test → lint → scan

Full Source Code
I’m publishing the entire system as I build it:

GitHub: https://github.com/gustavojofelix/digital-banking-suite/tree/feature/ch03-dev-environment

Want to Follow the Full Project?
I’m documenting EVERYTHING in a new step-by-step book:

*Leanpub (Early Access): *
fullstack-banking-microservices

New chapters every week.

If you're interested, I’d love your feedback — especially from .NET, Angular, and architecture folks.