Serverless Expense Tracker

Overview

I built this project to explore what a production-grade application looks like when you remove servers entirely. The app allows users to log, categorize, and review expenses through a fast Next.js frontend backed by AWS Lambda, API Gateway, DynamoDB, and Cognito.

The backend scales automatically from 0 to thousands of requests while costing almost nothing at idle making it ideal for indie developers and small teams.

Problem

Traditional backends (like Express on a VPS) run 24/7, costing $10–$15/month even with minimal usage. Add scaling, monitoring, and maintenance overhead, and the real cost increases quickly.

For an app handling only 50–100 requests per day, this is inefficient. I wanted to prove that a fully functional production app could run at near-zero cost while still handling real-world scale.

Solution

The entire backend is built using AWS managed services. API Gateway routes requests to Lambda functions, which handle business logic. DynamoDB stores data using a single-table schema optimized for fast queries, and Cognito manages authentication with JWT tokens.

The frontend is deployed on S3 and delivered globally through CloudFront, ensuring fast load times worldwide. This eliminates server maintenance while providing automatic scaling and high availability.

Key Features

• Secure authentication using AWS Cognito (JWT-based)
• Add, edit, and delete expense records with categories
• Serverless REST API using Lambda + API Gateway (auto scales to 10k+ req/sec)
• DynamoDB single-table design with <10ms query performance (p99)
• Frontend hosted on S3 + CloudFront (400+ edge locations)
• Runs at under $1/month at low traffic
• No servers to manage zero maintenance overhead

Tech Stack

System Architecture

Users authenticate via Cognito and receive a JWT token. Each request includes this token, which is validated by API Gateway before reaching Lambda blocking unauthorized requests early.

Lambda functions process business logic and interact with DynamoDB, which returns results in under 10ms. Static assets are served from S3 and cached globally via CloudFront, delivering sub-100ms load times worldwide.

How It Works

1. User signs up or logs in via AWS Cognito
2. JWT token is stored and sent with API requests
3. API Gateway validates token before invoking Lambda
4. Lambda executes business logic
5. DynamoDB processes queries (<10ms p99)
6. Response is returned instantly to the frontend

Demo

Challenges

• DynamoDB schema design: No joins or ad-hoc queries meant designing access patterns upfront. Used userId as partition key and date-based sort key for efficient queries.
• Stateless authentication: Instead of validating JWT in every Lambda (~50ms overhead), used API Gateway Cognito Authorizer to validate requests before Lambda runs.
• Cold start latency: Reduced cold starts from ~600ms to <250ms by keeping Lambda bundles under 1MB and optimizing initialization paths.