Vault Bank

Helps students invest smarter before they make costly mistakes

Comment

Inspiration

as a computer science student navigating tuition, investing, and everyday expenses, I realized something uncomfortable:

Most students are forced to make high-impact financial decisions with almost no guidance.

We’re told to budget. We’re told to invest. We’re told to “think long term.”

But no one gives us a safe environment to experiment.

VaultBank was inspired by the idea that financial learning shouldn’t require real financial loss. I wanted to build a system where students could simulate decisions, visualize long-term outcomes, and receive AI-driven feedback before committing real money.

The goal wasn’t just to build another dashboard — it was to create a financial co-pilot that makes discipline visible.

What it does

VaultBank is an AI-powered fintech dashboard that helps students make smarter financial decisions through simulation and real-time analysis.

The platform allows users to:

Simulate deposits, withdrawals, and transfers

Track account balances dynamically

Monitor recent spending activity

Evaluate purchases before committing

Receive AI-generated financial guidance based on account and transaction data

When a user considers spending money, VaultBank analyzes the decision using projected growth models such as:

\(A=P(1+r)t)\

This shows how today’s spending could impact long-term financial growth.

Instead of reacting emotionally to purchases, users can preview the financial consequences and receive structured feedback before making a decision.

VaultBank turns financial instinct into informed strategy.

How we built it

VaultBank was built as a lightweight full-stack fintech prototype focused on control, clarity, and stability.

Backend

The backend was built using Java’s built-in HttpServer, allowing us to manually define REST-style endpoints without relying on heavy frameworks.

Key backend features include:

Custom HTTP routing

In-memory account and transaction simulation

Transfer validation and balance integrity checks

JSON request and response handling

AI integration using Java’s HttpClient

We implemented endpoints such as:

/login

/me

/transactions

/transfer

/ai/chat

This approach gave us complete control over request parsing, validation logic, and financial simulation.

Frontend

The frontend was built using React + Vite to create a responsive fintech-style dashboard.

It includes:

A custom sign-in interface

Real-time balance display

Transaction history view

Transfer simulation

AI financial assistant panel

The frontend communicates with the backend via HTTP requests, keeping presentation and business logic cleanly separated.

Architecture Overview

User → React Dashboard → Java HTTP Server → • Account Simulation • Transaction Engine • AI Decision Logic

Everything runs locally to ensure reliability and fast demo performance.

Challenges we ran into

  1. API Key Security & Revocation

While integrating the AI model, our API key was automatically revoked after being flagged as exposed. We had to rotate the key, implement secure environment variable loading, and verify the correct working directory using a custom /debug endpoint.

This reinforced the importance of secure credential management in production systems.

  1. Manual Backend Routing

Because we built the backend using Java’s built-in HttpServer instead of a framework, we had to manually handle routing, JSON parsing, validation, and error handling.

While this gave us full control, it required careful debugging and testing to ensure stable request handling.

  1. AI Response Parsing

The AI endpoint required structured JSON output in certain modes. We had to implement logic to extract and coerce model responses into valid JSON objects to maintain reliability in decision mode.

  1. Scope Management Under Time Pressure

We had ambitious ideas — real brokerage integration, advanced analytics, deeper portfolio modeling — but we prioritized core simulation, transfer logic, and AI coaching to ensure a stable and demo-ready product.

The biggest challenge was balancing technical ambition with execution discipline — and choosing stability over feature overload.

Accomplishments that we're proud of

  1. Building a Full-Stack Fintech System From Scratch

We designed and implemented both the backend and frontend within the hackathon timeframe, including account simulation, transfer validation, and AI-powered financial guidance.

  1. Secure API Integration Under Pressure

After encountering an API key revocation issue, we successfully rotated the key, implemented environment-based loading, and ensured secure credential handling — turning a production-level problem into a stable solution.

  1. AI-Driven Financial Decision Mode

We implemented a structured decision-analysis mode that evaluates purchases using projected growth models and contextual spending data, returning structured JSON for consistent frontend rendering.

  1. Clean Architecture Without Heavy Frameworks

By building the backend using Java’s built-in HttpServer, we maintained full control over routing, validation, and response handling — demonstrating strong backend fundamentals.

  1. A Stable, Demo-Ready Product

Despite time constraints and debugging challenges, we delivered a polished, functional application ready for live demonstration.

What we learned

  1. Security Is Not Optional

API keys and credentials must be handled properly from the start. Experiencing an automatic key revocation reinforced the importance of environment variables, secure storage, and not hardcoding secrets into source code.

  1. Simplicity Can Be Powerful

Building the backend with Java’s built-in HttpServer forced us to understand routing, validation, and response handling at a deeper level. Avoiding heavy frameworks strengthened our fundamentals.

  1. Structure Matters in AI Integration

When integrating AI into financial workflows, structure is critical. We learned how to design prompts, enforce output schemas, and safely parse model responses into predictable JSON.

  1. Scope Discipline Wins Hackathons

Ambition is easy. Execution is harder. We learned to prioritize core functionality over extra features to ensure a stable, polished demo.

  1. Communication Is as Important as Code

A strong product must also be clearly explained. Translating technical implementation into a compelling narrative is just as important as writing the logic itself.

What's next for Vault Bank

VaultBank is currently a simulation-based fintech prototype, but the long-term vision is to evolve it into a fully functional AI-native financial platform.

  1. Live Market Data Integration

Integrate real-time stock and crypto APIs to allow users to simulate investments using live pricing data instead of static assumptions.

  1. Secure Authentication & Data Persistence

Implement JWT-based authentication and move from in-memory storage to a persistent database system for scalable user accounts and transaction history.

  1. Advanced Risk Modeling

Incorporate deeper financial modeling using expected return and long-term growth analysis:

\(E(R)=∑pi​ri \)​

and portfolio growth projections:

\(A=P(1+r)t\)

to give users structured insight into risk vs. reward.

  1. Personalized AI Financial Coaching

Expand the AI assistant to:

Analyze spending habits over time

Detect spending spikes

Recommend savings targets

Generate long-term wealth projections

Share this project:

Updates