Inspiration
Trace was inspired by a realization we had in the middle of building something completely different.
At the beginning of the hackathon, our team was working on another concept entirely. But as we collaborated, assigned tasks, and tried to keep track of progress, we kept running into the same invisible issue: our workflow wasn’t failing because of effort, it was failing because of dependencies.
We were using shared notes, spreadsheets, and verbal updates. Tasks were technically “assigned,” but no one could clearly see what was blocking what. Some teammates were overloaded, others were waiting, and small delays created ripple effects across the entire project. The problem wasn’t organization, it was visibility.
About 11 hours before the submission deadline, we made the decision to pivot almost entirely. We asked ourselves:
What if tasks weren’t just items in a list? What if they were part of a living system?
That question became Trace.
We wanted to build something innovative but not just another project management tool, but a system that understands how work connects. A platform that could take something static, like a spreadsheet, and transform it into an intelligent, dynamic network that reveals bottlenecks, auto-generates dependencies, and balances workload in real time.
Trace was inspired by the chaos we experienced and the belief that innovation doesn’t just mean adding features, it means rethinking the structure of how work flows.
What it does
Trace transforms static task lists into intelligent, dependency aware workflow systems.
Users begin by uploading an existing Excel or CSV file. Each row becomes a node in a dynamic visual graph. Instead of viewing tasks in isolation, Trace automatically generates connections between them by inferring logical dependencies based on order, deadlines, and task context.
Once the graph is created, users can clearly see how tasks relate to one another. If a prerequisite task is incomplete, downstream tasks are marked as blocked. As soon as a task is completed, the system updates in real time and automatically clears any dependent tasks.
Trace also allows users to expand any task into structured subtasks. With one click, the system generates smaller actionable steps and integrates them into the graph with proper connections. This ensures that large, abstract goals are broken down into manageable components.
To reduce bottlenecks, Trace includes an auto assignment engine. The system analyzes workload distribution across team members and suggests reassignment when someone is overloaded or when a task is blocking multiple downstream actions.
In short, Trace does not just track tasks. It understands how tasks connect, how work flows, and how to keep projects moving forward.
How we built it
We built Trace using Expo for the front end, Python for the backend logic, and MongoDB for data storage.
On the front end, we used Expo to rapidly prototype and design an interactive, responsive interface that visualizes tasks as a node based graph. The visualization layer dynamically renders nodes and edges based on project data, allowing users to interact with tasks, expand subtasks, and trigger auto assignment actions in real time.
On the backend, we implemented the core intelligence in Python. This layer handles Excel parsing, dependency inference, subtask generation, and workload optimization. When a user uploads a spreadsheet, the backend processes each row, converts it into structured task objects, and applies rule based logic to generate connections between tasks.
For auto dependency generation, we created an inference system that analyzes task order, due dates, and contextual keywords to establish likely prerequisite relationships. This transforms a flat list of tasks into a connected graph structure.
The auto assignment engine evaluates workload distribution across users by calculating active task counts and blocked dependencies. When imbalances are detected, the system suggests optimized reassignments to reduce bottlenecks.
All task and user data is stored in MongoDB, which allows flexible document structures for dynamic graph relationships. This was especially important because dependencies and subtasks can change and expand in real time.
Despite pivoting our entire concept 11 hours before submission, we rebuilt our architecture around a graph based workflow system and implemented the core pipeline: upload, generate dependencies, expand subtasks, auto assign, and dynamically update blocked states.
Challenges we ran into
The biggest challenge we faced was our decision to pivot almost entirely 11 hours before the submission deadline. We had already invested significant time into a different concept, and switching directions meant rebuilding both our technical architecture and our product narrative under intense time pressure.
One of the first technical challenges was converting a flat Excel file into a meaningful graph structure. Spreadsheets do not naturally encode dependencies, so we had to design logic that could intelligently infer relationships between tasks without creating chaotic or incorrect connections. Balancing automation with accuracy was difficult, especially within a limited timeframe.
Another major challenge was managing dynamic state updates. When a task changes from incomplete to complete, multiple downstream tasks may be affected. Ensuring that blocked states update instantly and consistently required careful coordination between the frontend visualization and backend logic.
Implementing the auto assignment engine also introduced complexity. We needed a scoring system that felt intelligent but was simple enough to implement quickly. Designing workload evaluation logic that was fair, predictable, and demonstrable within a hackathon environment required rapid iteration.
Finally, building a responsive node based visualization while maintaining performance proved challenging. Graph structures can become visually cluttered and computationally expensive, so we had to balance aesthetics with efficiency.
Despite these obstacles, the pressure of the pivot ultimately sharpened our focus. It forced us to strip the idea down to its core innovation and build only what truly demonstrated value.
Accomplishments that we're proud of
We are most proud of how our team stepped up and led at every level of this project.
When we decided to pivot our concept late into the hackathon, it required immediate clarity, trust, and decisive leadership. Instead of hesitating, each member took ownership of a critical component. One focused on rebuilding the backend logic, another redesigned the interface to reflect the new vision, and another refined the product flow and pitch narrative. There was no confusion about roles or responsibility. We aligned quickly and executed with purpose.
We are proud of the way we collaborated across technical and design boundaries. The frontend and backend were developed in parallel with constant communication to ensure the visualization layer and dependency logic worked seamlessly together. Decisions were made quickly but thoughtfully, with everyone contributing ideas and challenging assumptions.
We are also proud that we built a working pipeline as a team. From Excel parsing to dependency inference to auto assignment logic, every major feature reflects coordinated effort rather than isolated contributions. Trace feels cohesive because we built it cohesively.
Beyond the technical outcome, this project reflects strong teamwork, shared leadership, and the ability to adapt strategically. We did not just build a product. We built it together, with each person fully committed to making the vision real.
What we learned
This project taught us that innovation is not about adding complexity, but about reframing problems.
At first, we were focused on building features. After pivoting, we shifted our mindset toward systems. We learned that many workflow tools treat tasks as isolated units, when in reality they exist within interconnected structures. Thinking in terms of graphs instead of lists fundamentally changed how we approached both the technical architecture and the user experience.
We also learned the importance of decisive iteration. Recognizing that our original concept was not as strong as it could be required honesty and trust within our team. Making a strategic pivot forced us to prioritize what truly mattered and strip the product down to its core value.
Technically, we gained a deeper understanding of dependency modeling, state management, and workload optimization. Converting a flat spreadsheet into a dynamic graph required us to think critically about inference logic, data relationships, and real time updates.
Most importantly, we learned that strong communication and shared ownership accelerate execution. Clear roles, quick feedback loops, and confidence in one another allowed us to move forward without hesitation.
Trace reflects not just a technical build, but a shift in how we think about systems, collaboration, and problem solving.
What's next for Trace
Trace is currently a working prototype, but we see it evolving into a fully async native workflow intelligence platform.
Our next step is deepening the intelligence layer. We want Trace to learn from patterns over time so that dependency generation, subtask expansion, and workload optimization become increasingly personalized and predictive. Instead of reacting to blocked tasks, Trace will anticipate friction before it happens.
We also plan to strengthen the auto assignment engine by incorporating availability modeling, skill mapping, and adaptive workload balancing. The goal is to create a system that continuously redistributes work in a way that keeps momentum high without requiring meetings or manual coordination.
From a product perspective, we want to build Trace as an async first environment. Teams should be able to upload work, generate structure, optimize assignments, and move forward without needing constant check ins or backlog sessions. The system itself becomes the shared source of truth.
In the long term, we envision Trace defining a new category of async workflow systems. Not a task manager, but an intelligent orchestration layer that maps how work truly connects and continuously optimizes momentum across teams.
Log in or sign up for Devpost to join the conversation.