Banking Application

A full stack banking application using Node.js, React and MongoDB for deployment on Azure.

Features

Backend (Node.js + Express + TypeScript)

• Authentication & Authorization: JWT-based authentication with secure password hashing
• Account Management: Multiple account types (checking, savings, credit)
• Transaction Processing: Secure money transfers, deposits, and withdrawals
• Database: MongoDB with Mongoose ODM and atomic transactions
• Security: Rate limiting, input validation, CORS protection, helmet middleware
• API Documentation: RESTful API with comprehensive error handling

Frontend (React + TypeScript)

• Modern UI: Responsive design with Tailwind CSS
• Dashboard: Account overview with real-time balances
• Transaction Management: Transfer money between accounts with form validation
• Account Details: Transaction history with pagination
• Authentication: Secure login/registration with form validation
• State Management: Context API for authentication state

Database (MongoDB)

• User Management: Secure user profiles with encrypted passwords
• Account System: Multi-account support per user
• Transaction Ledger: Complete transaction history with references
• Indexes: Optimized queries for performance

Deployment (Azure)

• Container Apps: Scalable microservices architecture
• Container Registry: Private Docker image storage
• Infrastructure as Code: Bicep templates for reproducible deployments
• Monitoring: Application Insights and Log Analytics
• Security: Private networking and secure secrets management

Architecture

┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ │ │ │ │ │
│ React Frontend│◄──►│ Node.js API │◄──►│ MongoDB │
│ (Port 3000) │ │ (Port 3001) │ │ (Port 27017) │
│ │ │ │ │ │
└─────────────────┘ └─────────────────┘ └─────────────────┘

Getting Started

Prerequisites

• Node.js 18+ and npm
• MongoDB 7+
• Docker (for individual containers if needed)
• Azure CLI (for deployment)

Local Development

1. Clone the repository

   git clone <repository-url>

2. Install dependencies

   npm install

3. Set up environment variables

   cp .env.example .env
   cp backend/.env.example backend/.env
   cp frontend/.env.example frontend/.env

   Update the environment files with your configuration.

4. Start MongoDB

   # Using Docker (optional)
   docker run -d --name mongodb -p 27017:27017 mongo:7
   # Or install MongoDB locally# Follow: https://docs.mongodb.com/manual/installation/

5. Start the application

   # Start both frontend and backend
   npm run dev
   # Or start individually
   npm run backend:dev # Backend on http://localhost:3001
   npm run frontend:dev # Frontend on http://localhost:3000

API Endpoints

Authentication

• POST /api/auth/register - User registration
• POST /api/auth/login - User login

Accounts

• GET /api/accounts - Get user accounts
• GET /api/accounts/:id - Get account details
• GET /api/accounts/:id/transactions - Get account transactions

Transactions

• POST /api/transactions/transfer - Transfer money between accounts
• POST /api/transactions/deposit - Deposit money
• POST /api/transactions/withdraw - Withdraw money

Health Check

• GET /health - Application health status

Testing

# Run backend tests
npm run backend:test
# Run frontend tests
npm run frontend:test
# Run all tests
npm run test

Deployment to Azure

Prerequisites

• Azure subscription
• Azure CLI installed and logged in
• Docker installed

Deploy Infrastructure

1. Navigate to infrastructure directory

   cd infrastructure/azure

2. Run deployment script

   ./deploy.sh

   The script will:

   • Create Azure resource group
   • Deploy infrastructure using Bicep templates
   • Build and push Docker images to Azure Container Registry
   • Deploy container apps
   • Configure networking and security

Manual Deployment Steps

1. Create resource group

   az group create --name banking-app-rg --location eastus

2. Deploy infrastructure

   az deployment group create \
   --resource-group banking-app-rg \
   --template-file main.bicep \
   --parameters environment=prod

3. Build and push images

   # Login to ACR
   az acr login --name <registry-name># Build and push backend
   docker build -t <registry>.azurecr.io/banking-backend:latest ./backend
   docker push <registry>.azurecr.io/banking-backend:latest
   # Build and push frontend
   docker build -t <registry>.azurecr.io/banking-frontend:latest ./frontend
   docker push <registry>.azurecr.io/banking-frontend:latest

Security Features

• Authentication: JWT tokens with secure secret management
• Password Security: bcrypt hashing with salt rounds
• Input Validation: Express-validator for all API endpoints
• Rate Limiting: Protection against brute force attacks
• CORS: Configurable cross-origin resource sharing
• Helmet: Security headers for Express applications
• MongoDB Security: Connection string encryption and user authentication
• Container Security: Non-root user execution and minimal attack surface

Environment Variables

Backend (.env)

NODE_ENV=developmentPORT=3001MONGODB_URI=mongodb://localhost:27017/bankingJWT_SECRET=your-super-secret-jwt-key

Frontend (.env)

REACT_APP_API_URL=http://localhost:3001/api

Project Structure

banking-app/
├── backend/ # Node.js API server
│ ├── src/
│ │ ├── controllers/ # Route controllers
│ │ ├── models/ # MongoDB models
│ │ ├── routes/ # API routes
│ │ ├── middleware/ # Custom middleware
│ │ ├── services/ # Business logic
│ │ └── types/ # TypeScript types
│ ├── Dockerfile
│ └── package.json
├── frontend/ # React application
│ ├── src/
│ │ ├── components/ # React components
│ │ ├── pages/ # Page components
│ │ ├── services/ # API services
│ │ ├── hooks/ # Custom hooks
│ │ └── types/ # TypeScript types
│ ├── Dockerfile
│ └── package.json
├── database/ # Database configuration
│ └── init-mongo.js # MongoDB initialization
├── infrastructure/ # Azure deployment
│ └── azure/
│ ├── main.bicep # Infrastructure template
│ └── deploy.sh # Deployment script
├── docker-compose.yml # Removed (use individual services)
└── README.md

License

This project is licensed under the MIT License