#1 Forging FinWise: From Architectural Blueprint to a Live Full-Stack Foundation

#uncategorized

GitHub: https://github.com/DCodeWorks/FinWiseNest

Every solid software product starts with a strong foundation—not with dozens of features, but with smart decisions about structure and scalability. Over the past few weeks, I’ve been working on exactly that for FinWise , my new wealth management platform for the Swiss market.

This is a quick look at what I’ve built so far: from shaping the architecture to creating a real, working “vertical slice” of the application.

Starting with Architecture First

Before writing any production code, I focused on designing a scalable, reliable, and flexible architecture. I chose a decoupled microservices approach hosted on Azure Kubernetes Service (AKS).

This wasn’t just a technical preference—it was a strategic choice. I wanted to ensure that each service, like PortfolioService or TransactionService, could be built, updated, and scaled on its own, without affecting the others.

For the backend, I’m using .NET 9 , built around an event-driven design with Azure Service Bus. This means that when something like a transaction happens, the TransactionService just sends an event. Any other service that cares (for example, PortfolioService) can respond to it. This keeps the system loosely coupled and easier to maintain.

For data storage, I’ve gone with a polyglot persistence strategy:

Azure SQL for structured and transactional data, like portfolios and user transactions
Azure Cosmos DB for high-volume market data and time-series events
Azure Cache for Redis for caching, to keep things fast and responsive

The whole infrastructure is managed with Terraform , so I can recreate or update cloud resources with code. It’s clean, consistent, and future-proof.

Below overall architecture in this phase of the project, this will keep evolving as the project goes.

The Vertical Slice: Making It Real

Once the architecture was in place, I wanted to test the full flow with a real feature. I decided to build a “vertical slice” — one complete feature that connects the frontend, backend, and database.

I chose the Portfolio View as the first slice. Here’s how I put it together:

Frontend First (Next.js 14 + Tailwind CSS): I started by designing the UI using mock data. This helped me focus on layout, logic, and design, without worrying about backend code yet.
API Scaffolding (PortfolioService in .NET 9): Next, I created a microservice with a basic API endpoint that returned the same mock data. This gave the frontend a real URL to call, which made things feel much more “alive.”
Full-Stack Integration: Then came the exciting part—connecting the Next.js frontend to the backend service. After setting up CORS, the frontend was able to fetch live data from the backend running locally. It was the first moment everything came together.
Adding a Real Database (Entity Framework Core): Finally, I replaced the mock data with real data. I used Entity Framework Core to define the data models and generate the SQL schema. I updated the PortfolioController to query the database using a DbContext, and now the portfolio data is fully dynamic.

Where Things Stand Now

As of today, FinWiseNest has a working full-stack base: a user can load the app, which calls a .NET microservice, which then fetches data from a SQL database and shows the user’s portfolio. It’s a simple view, but it proves that the architecture and tech stack work well together.

This vertical slice validated the main design choices, and gives me a solid starting point for everything that’s coming next.