
How I Transformed My Budgeting Challenge into a Serverless Cloud Solution with AWS Amplify Gen 2
How I built Financial Flow, a serverless personal finance app using AWS Amplify Gen 2 to solve my budgeting challenges.


Introduction
One of the best ways to learn cloud technologies is by solving a real problem.
During my university journey, I tracked my personal expenses using a Notion document. Although it helped me record my spending, the process was entirely manual. I had to remember every purchase, update my records regularly, and calculate my remaining budget myself.
Like many students, I occasionally forgot to update my expenses. Small purchases quickly added up, and I sometimes exceeded my planned budget without realizing it until much later.
Rather than searching for another budgeting application, I decided to use this problem as an opportunity to learn AWS by building my own solution.
This project became my introduction to designing a serverless application with AWS Amplify Gen 2, Amazon Cognito, AWS AppSync, Amazon DynamoDB, and AWS Amplify Hosting.
Throughout this article, I'd like to share the AWS architecture decisions I made, what I learned during development, and why these services were a good fit for this project.
Starting with AWS Amplify Gen 2
Since this was my first project using AWS Amplify Gen 2, I wanted to understand how modern AWS application development differs from managing traditional backend infrastructure.
One of the things that immediately stood out was the ability to define cloud resources alongside application code.
Instead of manually creating services one by one through the AWS Console, Amplify Gen 2 allowed me to describe authentication, APIs, and data models as part of the project itself. This made it much easier to keep infrastructure and application code synchronized as the project evolved.
As the application grew, updating cloud resources became part of the normal development workflow rather than a separate deployment task.
Designing a Serverless Architecture
My goal was to build an application without managing virtual machines or backend servers.
Instead of worrying about operating systems, server maintenance, scaling, or patching, I wanted to concentrate on solving the budgeting problem.
The final architecture relied entirely on managed AWS services.
The overall request flow is straightforward:

Each service has a specific responsibility, making the architecture easier to understand and maintain.
Learning Authentication with Amazon Cognito
Since this project stores personal financial information, authentication was one of the first things I focused on.
Amazon Cognito provided an easy way to implement:
- User registration
- Secure sign in
- Identity management
- Access control
Instead of building my own authentication system, I could rely on a managed AWS service that follows security best practices.
Working with Cognito also helped me better understand how authentication integrates with other AWS services.
Connecting the Application with AWS AppSync
The next challenge was allowing the application to communicate with cloud data.
For this, I chose AWS AppSync.
Before starting this project, I had limited practical experience with managed GraphQL APIs.
Implementing AppSync taught me how GraphQL operations could simplify communication between the frontend and backend while integrating naturally with other AWS services.
Rather than creating REST endpoints manually, AppSync allowed me to focus on defining the application's data model and operations.
This significantly reduced the amount of backend code I needed to write.
Storing Data with Amazon DynamoDB
To store application data, I chose Amazon DynamoDB.
One of the reasons I selected DynamoDB was its simplicity within a serverless architecture.
Since the project manages financial records, I needed a database that could:
- Scale automatically
- Provide reliable performance
- Integrate well with AppSync
- Require minimal operational management
Working with DynamoDB also helped me better understand NoSQL data modeling and how managed databases differ from traditional relational databases.
Deploying with AWS Amplify Hosting
Deploying applications had previously involved several manual steps.
Using AWS Amplify Hosting simplified this workflow considerably.
By connecting the project repository, every code change automatically triggered a new deployment.
This continuous deployment process allowed me to focus more on development while AWS handled building and publishing the application.
It also gave me practical experience with CI/CD workflows that are commonly used in modern cloud applications.
What I Learned About Serverless Development
Before this project, I mostly thought about cloud computing as a place to deploy applications.
Building this project changed that perspective.
I began to understand how managed AWS services work together to reduce operational overhead while allowing developers to focus on application logic.
Instead of maintaining infrastructure, I could spend more time thinking about:
- User experience
- Application design
- Data organization
- Security
- Scalability
That shift in mindset was one of the biggest lessons I took away from this project.
Using AI as a Development Assistant
Throughout development, I also experimented with using Kiro as an AI development assistant.
Rather than asking it to generate complete solutions, I used it to:
- Discuss architecture ideas
- Explore implementation approaches
- Review code structure
- Debug problems
- Improve documentation
Using Kiro felt similar to having another developer available for discussion. It helped me evaluate different approaches, but the architectural decisions and implementation remained my responsibility.
This experience also taught me how AI tools can support software development while still requiring developers to understand the technologies they are using.
Challenges Along the Way
Like every learning project, this one presented several challenges.
One of the biggest was understanding how different AWS services interact.
Learning each service individually was relatively straightforward.
Understanding how Cognito, AppSync, DynamoDB, and Amplify work together as a complete solution required much more experimentation.
Another challenge was thinking in terms of managed services instead of traditional backend servers.
This project helped me gradually shift toward designing cloud-native applications rather than simply deploying existing software to the cloud.
Key Takeaways
Looking back, this project taught me much more than how to build a budgeting application.
It helped me learn:
- How AWS Amplify Gen 2 simplifies cloud application development
- How Amazon Cognito manages secure authentication
- How AWS AppSync provides a managed GraphQL API
- How Amazon DynamoDB fits naturally into serverless applications
- How AWS Amplify Hosting supports continuous deployment
Most importantly, it reinforced something I believe is valuable for anyone learning cloud technologies:
The best learning projects begin with solving a real problem.
Building something that matters to you keeps you motivated while giving you practical experience with the technologies you're learning.
Final Thoughts
This project started with a simple goal: make personal budgeting easier.
Along the way, it became an opportunity to explore modern serverless application development on AWS.
While there is still plenty to learn, building this project gave me practical experience with several AWS services working together in a real application.
If you're beginning your own AWS learning journey, my advice is simple:
Start with a problem you genuinely want to solve.
The technical knowledge will grow naturally as you build, experiment, and continue learning.
Thank you for reading. I hope my experience encourages other students and builders to explore AWS by creating projects that solve real-world problems.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article