Prism

Landing Page
Timeline Week View
Timeline Month View
Board View
Task Editing
Task Creation
Dependency Violation

Inspiration

We noticed a critical gap in how engineering teams (like Formula SAE and Capstone groups) and small businesses manage complex projects. Existing tools are either too simple (static to-do lists that ignore dependencies) or too complex (enterprise software that requires a certification to use).

The biggest pain point? The "Ripple Effect." When a hardware part is delayed by 3 days, teams struggle to instantly see how that impacts the final launch date. Furthermore, teams are afraid to innovate or change plans mid-flight because they can't simulate the consequences without breaking their current schedule.

We built Prism to solve this: a hybrid engine that combines rigorous Critical Path Method (CPM) execution with risk-free "What-If" Scenario Planning.

What it does

Prism is a dynamic project management platform that prevents "execution chaos" through three core systems:

The "Reality" Engine (Interactive Timeline): A React Flow-powered Gantt chart where dependencies are physical links. Dragging a task automatically ripples time changes to all dependent tasks, instantly highlighting the Critical Path (the sequence of tasks that directly dictates the project end date).

The "Graph Guard": An intelligent safety system that runs Depth-First Search (DFS) algorithms in real-time. It prevents users from creating logical paradoxes (circular dependencies) and alerts them to "orphan" tasks that have no clear start or end triggers.

Scenario Branching: A sandboxed environment where users can "fork" their live project. You can safely ask, "What if we added a new feature?" or "What if shipping takes 2 weeks longer?" without disrupting the actual team's workflow.

How we built it

We architected Prism as a modern, high-performance monorepo:

Frontend (The "Reality" Engine): We utilized the cutting-edge Next.js 16 (App Router) with React 19.

Visualization: React Flow (@xyflow/react) for the node-based Gantt chart and dnd-kit for the synchronized Kanban board.

State Management: Zustand stores handle the complex graph logic, ensuring that dragging a card on the Kanban board instantly updates the Gantt view (and vice versa) via optimistic UI updates.

Styling: Tailwind CSS paired with Shadcn/UI for a clean, accessible interface.

Backend (The Calculation Core):

Logic: A FastAPI (Python) microservice handles the heavy lifting, including the Critical Path Method (CPM) algorithm which computes Earliest Start (ES), Latest Finish (LF), and Float/Slack for every task.

Database: Supabase (PostgreSQL) serves as our source of truth, managing relational data for projects, tasks, and dependencies.

AI Integration:

We laid the groundwork for RAG (Retrieval-Augmented Generation) using pgvector to store project templates, allowing the system to suggest task lists based on historical engineering data.

Challenges we ran into

The Temporal Logic: Implementing the CPM algorithm (calculating forward and backward passes to find slack times) was mathematically challenging to sync with a drag-and-drop UI. We had to ensure that Earliest Start and Latest Finish times updated instantly without lag.

Cycle Detection: Allowing users to draw dependencies freely creates the risk of infinite loops (A depends on B, B depends on A). We had to implement a client-side Depth-First Search (DFS) algorithm (graphGuard.ts) that runs in under 100ms to snap the connection red and block the link before the user even releases their mouse.

State Synchronization: Keeping the Kanban board and the Timeline view in perfect sync was tricky. We used Zustand to create a single source of truth so that moving a card to "Done" physically shrinks the timeline bar in the other view.

Accomplishments that we're proud of

Custom CPM Implementation: We wrote our own Python implementation of the Critical Path Method that accurately calculates project slack and identifies the critical chain.

Modern Tech Stack: Successfully deploying Next.js 16 and React 19 before they are industry standard gave us access to the latest performance features but required navigating bleeding-edge documentation.

The "Graph Guard": It feels magical to try to create a loop and have the UI physically reject the connection with a "snapping" animation.

What we learned

Graph Theory in Practice: We gained a deep appreciation for Directed Acyclic Graphs (DAGs) and topological sorting, which are the computer science principles underlying every project schedule.

Microservices Pattern: separating the calculation logic (Python/FastAPI) from the application state (Next.js) allowed us to use the best language for each job—Python for math/AI, and TypeScript for UI interactivity.

What's next for Prism

We have a clear roadmap to turn this prototype into a daily driver for all users:

Planning Mode: A dedicated "drafting table" view where users can sketch out project structures and calculate timelines for hypotheticals before committing them to a rigid timeline.

AI Integration with Suggestions: Connecting our FastAPI service to an LLM to analyze task descriptions and suggest estimated durations (e.g., "3D Printing usually takes 4 hours, not 30 minutes").

Authentication & Teams: Rolling out full Supabase Auth to support multi-user organizations, allowing an entire Formula SAE team to log in and see their specific sub-team's tasks.

Multi-Project Support: A unified dashboard that overlays critical paths from multiple projects (e.g., Firmware vs. Hardware) to identify resource bottlenecks across the organization.

Automatic Delay Detection & Recalculation: The "Killer Feature"—if a task is not marked "Done" by its deadline, the system will automatically ripple the delay to all successor tasks and send a notification: "Project delayed by 2 days due to [Task X]. New completion date: March 15th."