Over the past few weeks, my focus hasn’t been on building flashy user interfaces or adding features.

Instead, I’ve been working on something less visible but far more important: building the foundation that every scalable software system depends on.

As the project leader for Skyline Computer World, my responsibility has been to ensure that our team starts with the right architecture instead of rushing into development. Good software isn’t just about writing code—it’s about making decisions today that will still make sense months or years from now.

Why Architecture Comes First

It’s tempting to jump straight into creating screens, APIs, or dashboards. But without a solid backend architecture, every new feature becomes harder to maintain.

That’s why I began by designing the core of our system.

Our backend stack consists of:

• NestJS for a modular and scalable server architecture

• PostgreSQL as the relational database

• Prisma ORM for type-safe database access and migrations

• TypeScript for maintainable and reliable code

• React + Vite for the frontend

• A shared package architecture to promote code reuse across applications

This gives us a strong foundation for long-term growth instead of a collection of disconnected features.

Designing the Database

One of the most rewarding parts of the project has been designing the database.

Instead of creating tables only for today’s requirements, I focused on a structure that can support future expansion.

The initial schema includes:

• User management

• Roles and permissions

• Customers

• Bank accounts

• Transactions

• Transfers

• Notifications

• Audit logs

Although Skyline Computer World is focused on technology retail and services, I’ve also been exploring banking system design as part of strengthening my backend engineering skills. Building secure financial systems is an excellent way to deepen knowledge of data integrity, transactions, authorization, and scalable architecture.

Lessons Along the Way

Not everything worked on the first attempt.

I spent time solving issues involving:

• PostgreSQL configuration

• Prisma migrations

• Environment variables

• Gradle and Android tooling

• Flutter development setup

• Database synchronization

• Monorepo project organization

Each obstacle reinforced an important lesson: software engineering is as much about debugging, persistence, and learning as it is about writing code.

Leadership Beyond Code

Leading a project isn’t just about contributing code.

It involves making technical decisions, helping teammates, documenting processes, planning future milestones, and ensuring everyone builds toward the same vision.

As a 20-year-old computer science student, I know I still have a lot to learn, but every project strengthens my understanding of software architecture, distributed systems, cloud technologies, cybersecurity, and AI integration.

What’s Next?

The next phase of development includes:

• JWT Authentication

• Role-Based Access Control (RBAC)

• RESTful API development

• Product management

• Inventory management

• Order processing

• Customer dashboard

• AI-powered features

• Cloud deployment

Every completed milestone brings Skyline Computer World one step closer to becoming a modern platform for technology products and services.

Final Thoughts

Software engineering isn’t about chasing the newest framework or writing the most code.

It’s about solving real problems, building systems that last, and continuously improving as an engineer.

I’m excited to continue documenting this journey—not only to share what I’m building, but also what I’m learning along the way.

The best systems are rarely built overnight. They are built one thoughtful decision at a time.

Subscribe now

From the project root:

mkdir backend
cd backend

Step 2: Install the NestJS CLI

npm install -g @nestjs/cli

Verify:

nest --version

Step 3: Create the NestJS Project

Inside the backend folder:

nest new .

Choose:

npm

Step 4: Start the Development Server

npm run start:dev

Expected output:

Nest application successfully started

Test:

http://localhost:3000

You should see:

Hello World!

PostgreSQL Setup

Step 5: Install PostgreSQL

Download and install PostgreSQL.

Verify installation:

psql --version

Expected:

psql (PostgreSQL) 18.x

Step 6: Connect to PostgreSQL

psql -U postgres

Enter your password.

Step 7: View Existing Databases

\l

Step 8: Create the Project Database

CREATE DATABASE wantam_holdings;

Verify:

\l

Step 9: Connect to the Database

\c wantam_holdings

Step 10: Check Tables

\dt

Initially:

Did not find any relations.

Prisma Setup

Step 11: Install Prisma

Inside the backend folder:

npm install prisma --save-dev

Step 12: Install Prisma Client

npm install @prisma/client

Step 13: Initialize Prisma

npx prisma init

This creates:

prisma/
.env
prisma.config.ts

Step 14: Configure the Environment

Edit .env

DATABASE_URL="postgresql://postgres:YOUR_PASSWORD@localhost:5432/wantam_holdings"

Replace:

• YOUR_PASSWORD
  

• database name if different
  

Step 15: Configure Prisma

Update prisma.config.ts

import "dotenv/config";
import { defineConfig } from "prisma/config";

export default defineConfig({
  schema: "prisma/schema.prisma",
  migrations: {
    path: "prisma/migrations",
  },
  datasource: {
    url: process.env["DATABASE_URL"],
  },
});

Step 16: Configure the Schema

Replace schema.prisma with your banking models.

Example sections:

generator client {
  provider = "prisma-client"
  output   = "../generated/prisma"
}

datasource db {
  provider = "postgresql"
}

Then define:

• Enums
  

• Role
  

• User
  

• Customer
  

• Account
  

• Transaction
  

• Transfer
  

• Notification
  

• AuditLog
  

Step 17: Create the Initial Migration

npx prisma migrate dev --name init

Step 18: Update the Schema

After expanding the banking models:

npx prisma migrate dev --name add_banking_models

Expected:

Applying migration...

Your database is now in sync.

Step 19: Check Migration Status

npx prisma migrate status

Expected:

Database schema is up to date.

Step 20: Verify Tables

Connect to PostgreSQL:

psql -U postgres

Connect:

\c wantam_holdings

View tables:

\dt

Expected:

Account
AuditLog
Customer
Notification
Role
Transaction
Transfer
User
_prisma_migrations

Useful Prisma Commands

Generate Prisma Client

npx prisma generate

Reset Database

npx prisma migrate reset

Create New Migration

npx prisma migrate dev --name migration_name

Check Migration Status

npx prisma migrate status

Pull Existing Database

npx prisma db pull

Push Schema (without migrations)

npx prisma db push

Open Prisma Studio

npx prisma studio

Useful PostgreSQL Commands

Connect

psql -U postgres

List Databases

\l

Connect Database

\c wantam_holdings

Show Tables

\dt

Describe Table

\d "User"

Exit

\q

Backend Project Structure

backend/
│
├── prisma/
│   ├── migrations/
│   ├── schema.prisma
│   └── prisma.config.ts
│
├── src/
│   ├── app.controller.ts
│   ├── app.service.ts
│   ├── app.module.ts
│   └── main.ts
│
├── generated/
│   └── prisma/
│
├── .env
├── package.json
├── tsconfig.json
└── nest-cli.json

Git Commits Used

Initialize backend:

git commit -m "feat(backend): initialize NestJS backend"

Set up PostgreSQL and Prisma:

git commit -m "feat(database): configure PostgreSQL and Prisma ORM"

Create banking schema:

git commit -m "feat(database): implement initial banking database schema"

After migrations:

git commit -m "feat(backend): set up NestJS backend with Prisma and PostgreSQL"

Next Phase

With the backend infrastructure complete, the recommended implementation order is:

1. Create the Prisma Module (PrismaModule and PrismaService).
   

2. Implement Authentication (JWT + BCrypt).
   

3. Build the Roles and Users modules.
   

4. Develop the Customers module.
   

5. Implement Accounts.
   

6. Add Transactions and Transfers.
   

7. Create Notifications and Audit Logs.
   

8. Generate Swagger/OpenAPI documentation.
   

9. Connect the Flutter frontend to the REST API.