FlatFlow: 4 Days Building a Serverless App on AWS
How four VIT Pune students shipped a serverless financial transparency app in 96 hours for the WeMakeDevs x AWS First Commit hackathon.
This is the story of how four students from VIT Pune built and shipped a full serverless app in 96 hours for the WeMakeDevs x AWS First Commit hackathon — and everything that tried to stop us.
Our project is called FlatFlow. It's a financial transparency tool for residential apartment societies in India. If you've ever lived in an apartment, you know the pain: every month you pay ₹5,000 as "maintenance," and the only thing your payment app tells you is "maintenance." No breakdown. No category. No way to know where the money went. Our app fixes that.
The idea: the RWA admin enters the month's expenses, our backend calculates each flat's share, and residents see a personalized itemized statement with a chart and can ask AI questions about it.
Here's what actually happened when we tried to build it.
The Stack
We decided early to go serverless. None of us had built anything on AWS before, so we picked the standard stack and hoped for the best:
AWS Lambda (Python 3.12) — 8 functions
Amazon DynamoDB — single-table design
Amazon API Gateway — REST API with 8 routes
Amazon Cognito — User Pools with Admin and Resident groups
Amazon S3 — for bill uploads
Amazon Bedrock — for the AI layer
Amazon Textract — for OCR on bills
AWS Amplify — for frontend hosting
All in ap-south-1 (Mumbai).
The Things That Fought Back
DynamoDB hates floats.
This is a thing every DynamoDB tutorial mentions but you don't internalize until your Lambda crashes with TypeError: Float types are not supported. Use Decimal instead. We had to convert every rupee amount to Decimal(str(amount)) — the string wrapper matters because Decimal(10000.0) can give you weird precision artifacts like 10000.00000000001. Cost us about an hour.
Lambda Proxy Integration is not obvious.
When you attach a Lambda to API Gateway, you have a choice between "Lambda Function" and "Lambda Proxy." We picked the wrong one first and spent 40 minutes wondering why event['body'] was always empty. The answer: only Lambda Proxy passes the full HTTP request shape (including the JSON body as a string) into your function. Regular Lambda Integration expects you to map fields manually, which we hadn't set up.
Cognito Hosted UI redirect URLs.
Cognito won't redirect back to your app unless the URL is explicitly whitelisted. We had to add both our local development URL and the hosted URL to the allowed callback list in Cognito. If you skip this, login fails with redirect_mismatch and there's no obvious hint about what to fix.
The Bedrock API changed and nobody told us.
We spent hours debugging ValidationException: Operation not allowed before realizing AWS had moved from invoke_model with anthropic_version to the newer Converse API. Half the tutorials online still show the old format. Once we switched to the Converse API and Amazon Nova Lite, the code worked.
Our AWS account wasn't verified for Bedrock or Textract.
This is the one that genuinely blocked us. New AWS accounts go through a verification process, and until it clears, services like Bedrock and Textract throw SubscriptionRequiredException or authorizationStatus: NOT_AUTHORIZED. The error messages don't say "your account needs verification" — they just say "you need a subscription," which sends you down a rabbit hole of IAM policy debugging. We filed a support case but the review takes 24+ hours, so we shipped the demo with the AI layer mocked and the code fully written and deployed, ready to run once the account clears.
What Worked
Despite all that, the parts that worked, worked beautifully.
Lambda was a joy. We deployed 8 functions in about 3 hours and never touched a server. Cold starts were sub-second. CloudWatch Logs saved us dozens of times — every print() statement in a Lambda shows up in the logs within seconds, which makes debugging trivially fast compared to console.log in a browser.
DynamoDB single-table design, once we understood it, made our queries incredibly efficient. We store societies, expenses, and statements all in one table using a PK/SK pattern. Querying "give me every September expense for society S001" is one line of Python using a KeyConditionExpression with begins_with on the sort key. That returns in milliseconds and costs essentially nothing on the free tier.
Cognito genuinely felt like cheating. Two User Groups, one Hosted UI, and suddenly we had production-grade authentication without writing a single line of auth code. The JWT claims get passed automatically into every Lambda via API Gateway, so enforcing role-based access was a five-line helper function that checks the group claim and returns 403 if the user is in the wrong role.
API Gateway + CORS was straightforward once we got past the Proxy Integration confusion. Enabling CORS on each resource and deploying to a prod stage took about 30 minutes for the whole API.
What We Shipped
By the end of Day 4, we had:
- 5 core Lambda functions deployed and tested end-to-end
- 3 additional Lambda functions for bill processing (upload working, OCR path blocked by AWS account verification)
- An API Gateway with 8 routes, all behind a Cognito Authorizer
- A DynamoDB table with a clean single-table schema
- A working S3 bill upload flow, tested end-to-end with real invoice PDFs
- Cognito auth with Admin and Resident groups, and role-based access working across the API
- A React frontend with multiple pages, including an admin dashboard for entering expenses and a resident view that shows the per-flat amount and category breakdown
- A Bedrock integration that is fully written but could not be invoked because our AWS account isn't verified for Bedrock yet
- A Textract integration that is fully written and was tested against a real invoice PDF in S3, but throws SubscriptionRequiredException because our account isn't verified for Textract yet
- The repo is hosted publicly on GitHub.
What We Learned
We came in knowing Python and React. We came out knowing serverless architecture, single-table DynamoDB design, Cognito RBAC, API Gateway routing, and how to debug AWS services that give misleading error messages. That last one might be the most valuable skill of all.
Three things I'd tell anyone doing their first AWS hackathon:
Read the exact error message. SubscriptionRequiredException and authorizationStatus: NOT_AUTHORIZED mean your account, not your code.
Enable Lambda Proxy Integration on every method. Always.
Set a $5 AWS Budget alert on Day 1. It takes 2 minutes and it saves you from a very bad Monday.
The whole thing runs on AWS, scales to any number of societies, and costs us almost nothing while idle. That's the magic of serverless.
—
Built by: Shreyas Madake, Bhakti Ugale, Ronak Gohel, Kaustubh Marathe
Hackathon: First Commit, Bharat Builds Tour (WeMakeDevs), Sept 2026
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article