Growth OS

Inspiration:

Growth OS began with a simple but revealing moment. One of us asked ChatGPT, "Can you look at my current chat history, conversations, and memory and give me feedback about myself?" Even with very limited data and a reliably persistent memory, the response was surprisingly thoughtful. It offered advice that felt personal, even reflective. That moment sparked a powerful idea: what if we could build a system that didn’t just answer questions in the moment, but understood us over time?

We realized that personal growth, real, sustained progress, requires more than knowledge. It requires structure, reflection, feedback, and continuity. People track their work, their workouts, even their finances, but there’s no operating system for tracking who you are becoming. And yet, the raw materials are already around us: goals, habits, notes, reflections, learning moments, calendar events, even the way we spend our time online. We just don’t have a system that brings it all together.

That’s where the idea for Growth OS was born. We wanted to create an intelligent, evolving model of each person, something that could learn how you learn, track your growth across time, and help you become the version of yourself you aspire to be. Not just smarter AI, but smarter you.

We started by identifying the foundational features that would make the biggest difference right away. That led to the Knowledge Curation system and the Self-Testing engine. These features were designed to help users start building their knowledge base and measure progress in a way that feels tangible. The goal was never just to build a chatbot or a note-taking app, but to begin laying the groundwork for a personal growth system that learns and grows with you.

This hackathon gave us the push we needed to bring that vision into a working MVP. It's still early, but the idea is real, and the potential is huge.

What It Does:

Growth OS is a personal growth and knowledge operating system built to help ambitious individuals become who they want to be. At its core, it creates a dynamic model of the user your goals, habits, knowledge, and progress, and uses this model to deliver personalized guidance, proactive insight, and measurable growth over time.

The long-term vision is to create an intelligent, evolving system that acts as your coach, strategist, and assistant. It would guide your learning, prompt reflection, track your habits, assess your skills, and help you close the gap between where you are and where you want to be. It would integrate deeply with your tools and routines, automatically curating knowledge, surfacing blind spots, and ensuring that all your growth data works together in one unified ecosystem.

Today, we’ve taken the first steps toward that vision. Our MVP includes:

• A simple but functional user model, where each user defines a single core goal, complete with a timeline, domain, and personal motivation. This goal serves as the foundation for personalization across the system.
• A working knowledge curation engine that allows users to input raw text and receive structured, AI-assisted suggestions on how to organize and store that information in their database. It intelligently recommends whether to merge, create, or discard knowledge entries based on semantic similarity, all within a framework of 52 core categories.
• A self-testing feature that enables users to assess their knowledge within specific categories. Users choose the number of questions and format (multiple choice or free text), receive AI-generated feedback, and build a living Mastery Score that evolves with repeated testing.
• A dashboard that visualizes their progress, showing how their knowledge is distributed, how their test scores are trending, and how close they’re getting to mastering key categories tied to their growth.

Even though the current version is limited, just one goal at a time, basic text inputs, and straightforward testing, we've already seen how powerful it can be when you start turning scattered learning into structured, measurable growth. Each feature is a stepping stone toward a larger, more ambitious system. Growth OS is not just another productivity app or AI wrapper. It’s a foundation for transformation, built with the belief that AI should help you become more you.

How We Built It:

We started by building the core of our system: the Knowledge Curation pipeline. From the beginning, we knew that capturing and organizing knowledge wasn’t enough—it needed to feel intelligent, helpful, and efficient. To achieve that, we designed a two-phase pipeline that splits responsibilities between the backend and frontend for performance and scalability.

In Phase 1, handled entirely on the Python backend, we first generate vector embeddings from the user’s input text. These embeddings are compared against existing entries in the database to find similar knowledge items using custom similarity logic. We then pass the matched context into an LLM, which returns three recommendations on how the input should be stored—whether to merge it with an existing item, create something new, or discard it. These suggestions are shown to the user on the frontend.

Once a recommendation is selected, Phase 2 takes over. It transforms the knowledge input to fit the selected category and structure, enriching it into a final form before saving it to the database. This multi-step curation process ensures that knowledge is both relevant and consistently organized.

Next, we built the Self-Testing feature. We didn’t want Growth OS to just organize knowledge—we wanted users to actively retain and reinforce it. So we created a testing engine where users can generate questions based on their curated knowledge. Using Azure’s OpenAI models, the system creates either multiple-choice or free-text questions tied to specific knowledge items. Users then test themselves and receive scores, feedback, and an evolving Mastery Score for each main category. This gives them a clear picture of how well they understand what they’ve learned.

To bring it all together, we built a dashboard that lets users track their progress over time, viewing test score trends, average performance, category breakdowns, and their most recent activities.

On the technical side, the frontend was built with Next.js using the App Router, styled with Tailwind CSS, and powered by Recharts for visualizations. The backend runs on FastAPI with Python, integrating Azure OpenAI for all knowledge and testing workflows. We use Supabase for authentication and our PostgreSQL database, and host our backend on Railway.

From embedding-based semantic search to LLM-driven knowledge transformation and scoring, every part of the stack was built to support our long-term vision: turning raw learning moments into measurable growth.

Challenges We Ran Into:

One of the biggest challenges we faced was integrating our Python FastAPI backend into the Bolt development environment. At the time, Bolt only had native support for full-stack applications, so introducing a standalone backend architecture created friction early on. That said, we were still able to use Bolt effectively as a development advisor; it helped us scaffold and streamline our backend logic in a way that complemented the frontend.

Another major challenge was collaboration within Bolt itself. Vibe coding with multiple teammates turned out to be quite tricky. Since each team member had to import the project separately, we found ourselves editing the same files simultaneously, often unaware of each other’s changes. Because Bolt moves fast and writes directly to the shared repository, it was hard to track what was changing and where each feature lived. This made version control and coordination more chaotic than expected.

On the AI side, the main hurdle was designing prompts and managing context for the various LLM tasks across the app. We wanted to strike a balance between fast, responsive AI outputs and high-quality, context-aware results. Optimizing for both user experience and LLM accuracy meant a lot of experimentation with prompt structure, token limits, and trade-offs in determinism versus variability. It was a constant back-and-forth to make sure responses were helpful, relevant, and efficient for real-time use.

In short, we had to navigate both technical and collaboration challenges, especially when it came to tooling limitations and AI design, but each roadblock helped us better understand our architecture and tighten the system.

Accomplishments That We're Proud Of:

As a team working together for the first time and building on a tight hackathon timeline, we’re genuinely proud of everything we’ve accomplished so far. Each feature we shipped pushed us to balance vision with practicality, and while there's still a long road ahead, what we’ve built is a solid foundation that already delivers value.

What stands out the most is the Knowledge Curation feature. This was the most technically and conceptually challenging piece of the system, and the one we spent the most time refining. It allows users to input unstructured text, anything they’ve learned, read, or thought about, and get back smart, contextualized suggestions on how to store that information meaningfully in their database. Whether it merges with an existing knowledge item or creates a new one, it helps turn chaotic input into structured insight. For an MVP, it’s surprisingly fluid and already feels useful in practice.

We’re also proud of how the pieces work together, even in their early form. The way a user’s goal influences knowledge curation, how self-testing creates evolving Mastery Scores, and how the dashboard surfaces that progress shows that the core loop is real. It’s early, yes, but the feedback cycle between learning, organizing, testing, and reflecting is already alive in the product.

Most importantly, we’re proud that we didn’t compromise on our long-term vision. Every feature we implemented was intentionally scoped to support where we want Growth OS to go. Even though we started small, everything is built with extensibility and future complexity in mind. This isn't just a prototype, it’s a launchpad.

What We Learned:

As mostly non-experienced coders, one of our biggest hurdles was architectural design. At the start, we didn’t know how to structure a full-stack project like this, from the flow between frontend and backend to how data should be passed, stored, and managed. But thanks to Bolt’s seamless integration and real-time coding assistance, we were able to start doing before we fully understood the thinking. That momentum gave us confidence to move forward even when we weren’t sure how everything would come together.

With Bolt handling much of the heavy lifting on the code side, we were free to focus on the most important part: our ideas. We didn’t get stuck trying to resolve syntax issues or debug setup problems; instead, we could keep building. That freedom helped us learn by seeing: watching how code was generated, edited, and structured gave us a more intuitive sense of how industry-grade systems are written.

Vibe coding on Bolt wasn’t just smooth, it was educational. By the end of the hackathon, we had a much better grasp of what clean architecture looks like, how frontend and backend APIs interact, and how to properly manage state, data flow, and modularity.

Along the way, we also learned how to work with a modern AI-first stack, including:

• Next.js with App Router for dynamic frontend routing
• Tailwind CSS for styling and reusable UI components
• FastAPI for building structured, scalable Python backends
• Supabase for authentication, database, and real-time sync
• Recharts for data visualization
• Azure OpenAI for embedding generation, text transformation, question generation, and feedback evaluation

While we may not code like senior software engineers yet, Bolt elevated us closer to that level. It gave us a runway to learn while building something real, and by the end, we weren’t just watching the code; we understood how it fit together. That learning has been one of the most rewarding parts of this entire experience.

What's next for Growth OS:

What we’ve built so far is just the beginning. The MVP has given us proof that the core ideas behind Growth OS, personalized growth, structured knowledge, and evolving insight are not only possible but already useful. Now, it’s time to push further.

In the short term, we plan to enhance what’s already working. That means improving the quality of our AI prompts, making the knowledge curation smarter and more nuanced, adding more flexibility to self-testing, and giving users better tools to manage multiple goals. We’ll also refine the user interface and overall experience to make the platform feel more fluid, more intuitive, and more deeply personal.

Beyond the MVP, our roadmap includes support for file and web-based knowledge ingestion, richer user modeling with evolving traits and multi-goal planning, habit tracking, longitudinal insights, and proactive agent workflows that can recommend next steps, identify gaps, and help users stay aligned with their aspirations. The system will become less reactive and more anticipatory, growing with the user and acting as a real partner in their journey.

But this isn’t just a product vision. It’s the beginning of a company. Our team is planning to turn Growth OS into a real startup with a clear mission: to help people become who they truly want to be. In a world full of noise, distraction, and fragmented tools, we believe people deserve an intelligent foundation that supports long-term growth. Growth OS is that foundation, and this hackathon is just the first step in building it.

Built With

• bolt
• fastapi
• javascript
• netlify
• next.js
• railway
• react
• supabase