
Weekend Showcase Challenge: Hackathon Copilot
What if you had an AI teammate that could take your hackathon idea from initial scope to MVP, architecture, tasks, review, demo, and pitch? Hackathon Copilot is a state-aware AI development teammate built and deployed on AWS to help builders focus on shipping instead of getting lost in scope.
Weekend Showcase Challenge: Hackathon Copilot
Hackathons are exciting because they give us a limited amount of time to turn an idea into something real. But that same time constraint can quickly become a problem. Ideas become too ambitious, features keep getting added, technical decisions become rushed, and the final hours are spent trying to make everything work well enough for a demo.
For the Summer Builds Showcase, I wanted to build something around that exact problem.
I built Hackathon Copilot — an AI-powered development teammate that helps a builder go from a raw idea to a working, demo-ready MVP.
The journey is:
IDEA → PROBLEM → MVP → ARCHITECTURE → TASKS → BUILD → REVIEW → DEMO → PITCH
The goal wasn't to create another chatbot with a dashboard around it. I wanted to build an AI teammate that understands the current state of a project, challenges unrealistic decisions, remembers previous choices, and recommends the next best action.
What does Hackathon Copilot do?
The experience starts with the builder's idea.
Hackathon Copilot analyzes the problem, target users, assumptions, risks, complexity, and feasibility. It produces a score across five dimensions and, importantly, can challenge the builder when the idea is too broad.
The next step is defining the MVP.
Instead of simply generating a long list of features, Hackathon Copilot separates them into:
- Must Have
- Nice to Have
- Future
There is also a Reduce Scope option designed to help a builder quickly get back to the smallest useful MVP.
Once the scope is clear, Hackathon Copilot creates an AWS architecture based on what the project actually needs. Each recommended service includes its purpose, reasoning, alternatives, and tradeoffs.
It then turns the plan into an ordered task board with priorities, estimates, dependencies, and progress tracking.
And this is where the AI teammate becomes particularly useful.
An AI teammate that can push back
A major design goal was to make the AI state-aware.
The mentor follows an agent-style loop:

Because project state is persisted, the mentor can consider previous decisions, the current MVP, completed tasks, remaining work, and project progress before making a recommendation.
For example:
Builder: “I want to add 10 more features.”
Mentor: “You have ~25h of planned work left and the MVP is 55% done. Do NOT add features. Finish the core loop first.”
That behavior is intentional.
A hackathon teammate shouldn't always tell you that your idea is great. Sometimes the most useful thing it can do is tell you no.
Building it on AWS
Hackathon Copilot is deployed using AWS services across the frontend, backend, AI, persistence, and observability layers.
The frontend is built with React 18, React Router, Vite, and a custom responsive CSS design system. It is hosted on Amazon S3 and delivered through Amazon CloudFront, providing the public HTTPS application.
The backend uses Node.js 20 and Express and runs on AWS Lambda. Requests from the frontend pass through Amazon API Gateway (HTTP API) before reaching the Lambda backend.
Project memory is stored in Amazon DynamoDB. The database stores the project idea, MVP, architecture, tasks, decisions, mentor interactions, reviews, and demo/pitch information.
For AI capabilities, I integrated Amazon Bedrock with Amazon Nova. Bedrock enriches narrative outputs such as mentoring and pitch content, while a deterministic reasoning engine handles structured workflow decisions and scoring.
I also use Amazon CloudWatch for structured logs and troubleshooting, with AWS IAM providing least-privilege permissions.
The architecture looks like this:

The architecture was deliberately kept simple. One of the principles behind Hackathon Copilot is that builders should use the infrastructure they actually need rather than adding services just because they are available.
Key technical decisions
One important decision was making the same Express application work both locally and in Lambda. This keeps development and production behavior consistent.
I also implemented a deterministic reasoning fallback.
When live AWS access isn't available, the application can still run end-to-end using the local reasoning engine and a local JSON data store. When Amazon Bedrock is enabled, Nova enriches the narrative parts of the experience.
This gave me a useful balance between predictable structured behavior and AI-generated responses.
For persistence, DynamoDB uses a simple single-table approach with one project item keyed by an
id . This is enough for the current hackathon-scale workload while keeping the data model straightforward.From idea to complete workflow
The application doesn't stop after generating an MVP.
The complete workflow includes:

1. Idea Analyzer
Analyzes the problem, users, risks, assumptions, complexity, and feasibility.
2. MVP Generator
Creates Must/Nice/Future features and helps reduce scope.
3. AWS Architect
Designs a practical AWS architecture with service decisions and tradeoffs.
4. Task Board
Creates an ordered implementation plan with priorities, estimates, dependencies, and status.
5. AI Mentor
Uses project state to identify blockers and prevent scope creep.
6. Dashboard
Shows progress, stage completion, blockers, remaining time, and the next best action.
7. Project Review
Reviews functionality, architecture, security, scalability, UX, innovation, and documentation.
8. Demo & Pitch
Generates a 30-second pitch, 60-second demo script, 3-minute presentation structure, and potential judge questions.
I also included a CampusConnect sample project so anyone opening the live application can click Try Demo Project and experience the complete workflow without having to create a project from scratch.
Testing the workflow
I wanted to make sure the individual features worked together as one system rather than becoming disconnected AI screens.
The backend includes tests covering the major workflow:

The tests can run offline with Bedrock disabled, making the core workflow predictable and fast to validate.
Observability and security
The backend emits structured JSON logs for API requests, workflow steps, AI success/fallback events, and persistence operations.
When running on Lambda, these logs flow into Amazon CloudWatch, where they can be queried using Logs Insights.
I also designed the Lambda execution role around least privilege. It only receives the DynamoDB and Bedrock permissions required by the application, rather than broad AWS permissions.
No AWS credentials are exposed in the frontend.
What I learned throughout the Summer Builds journey
One of my biggest takeaways from building this project was that creating an AI application is not simply about connecting an LLM to a UI.
The state around the AI matters.
If an AI teammate doesn't know what has already been decided, what has been completed, how much work remains, or what the current MVP looks like, its recommendations quickly become generic.
Persisting project state changed that.
I also learned that deterministic logic and generative AI don't have to compete with each other. Using deterministic reasoning for structured decisions while using Amazon Bedrock and Nova for narrative enrichment helped make the application more reliable while still giving it an AI-powered experience.
And perhaps the biggest lesson was about scope.
During a hackathon, there is always another feature you could add.
Sometimes the best engineering decision is to stop building and ship what you already have.
That became one of the central ideas behind Hackathon Copilot.
Try Hackathon Copilot
The application is live on AWS:
Open the application and click Try Demo Project to experience the CampusConnect workflow.
The project uses:
React • Vite • Node.js • Express • Amazon Bedrock • Amazon Nova • AWS Lambda • API Gateway • Amazon DynamoDB • Amazon S3 • Amazon CloudFront • Amazon CloudWatch • AWS IAM
Bringing the Summer Builds journey together
Hackathon Copilot is my attempt to bring together the lessons from building with AWS, experimenting with AI, designing serverless applications, and thinking about how agents can actually help people get work done.

The original question was simple:
What if, instead of building alone during a hackathon, you had an AI teammate that actually understood what you were building?
That question became Hackathon Copilot.
From challenging the initial idea to defining the MVP, designing the AWS architecture, generating tasks, tracking progress, reviewing the project, and preparing the final pitch — the goal is to keep the builder moving toward one outcome:
shipping.
From raw idea to working MVP with an AI teammate. 🚀
A huge thank you to the AWS Builder Community and everyone who shared their builds, ideas, and knowledge throughout the Summer Builds series.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article