IncidentLens

Incident-Lens
Flash Sale after synthesis
Postmortem tab
Database Deadlock Synthesis
Live Messy Chat Synthesis

Inspiration

There was a Java project that we had to build for college as a four-member group project. We developed a Vehicle Service Management application entirely in Java, but on the day of the presentation, the application stopped working.

We had only two to three hours to get it working again before the presentation. We made several changes under time pressure, managed to get the application running, and successfully presented it.

However, when we later wanted to improve the project further, we found ourselves stuck. The changes we had made in a hurry were largely unplanned and unsystematic, making it difficult to understand exactly what we had changed and how everything worked. As a result, we struggled to build upon our own project.

That experience inspired us to build IncidentLens.

What it does

Paste an outage chat or load a built-in sample, then click Synthesize. The tool generates a milestone timeline, highlights the root cause, flags wrong turns with the time lost to each, and compares the time wasted on wrong turns with the rest of the incident.

Click any milestone to view the exact chat lines behind it. With one click, export a postmortem and follow-up tasks.

In the Flash Sale sample, 17 of the 40 minutes were spent chasing Redis.

How we built it

Built using React, Vite, TypeScript, and Tailwind CSS, the application runs entirely in the browser without requiring a backend.

We followed the hackathon’s AI-assisted planning workflow, using AI coding agents to define the scope, develop the PRD and technical specification, create an implementation checklist, and build the application incrementally through vertical slices.

The application includes two built-in outage samples with precomputed, verified results, allowing users to explore its capabilities immediately. For custom incident logs, users can provide a free Gemini API key to let the AI analyze the numbered chat lines and identify key milestones, potential root causes, and incorrect troubleshooting paths.

To improve reliability, we validate each identified milestone against the original log and calculate the time lost using actual timestamps. This combines AI-driven incident analysis with deterministic verification, making the resulting timeline and postmortem more traceable and evidence-based.

Challenges we ran into

This build came with a few lessons we didn’t expect. Our first offline mode generated a timeline for any pasted log, even when the evidence wasn’t there. We caught that and removed it rather than presenting made-up results as facts.

We also found that the model’s estimates of time lost didn’t always match the actual timestamps, so we changed the app to calculate those figures directly from the logs instead of relying on the AI. In another case, a number in one of our built-in samples contradicted the chat itself, which reminded us that even examples need to be verified. And because the free Gemini tier sometimes returns overload errors, we added retries to make the experience more resilient.

These weren’t just bugs to fix. They changed how we approached the project. We learned that using AI to analyze an incident is only part of the problem; the results also need to be grounded in evidence, checked against the original conversation, and honest about what the logs can actually tell us.

Accomplishments that we're proud of

We’re genuinely proud that we managed to complete and submit IncidentLens before the deadline. This was our first hackathon on Devpost, and being able to take an idea from scratch and turn it into something we could actually submit feels like an achievement in itself.

Finding the right idea was hard. Coming up with something unique was hard. Bringing all the pieces together and making them work was even harder. On top of that, we had college exams to deal with, but we still managed to find time for this project and see it through to the end.

We don’t know whether we’ll win a prize. Of course, we’re excited about that possibility, and we’d be lying if we said we didn’t hope for it. But we also know that winning isn’t the only thing that makes this experience worthwhile.

For now, we’re happy that we showed up, put in the work, learned from our mistakes, and finished what we started. This was something new for us, and we’re proud that we had the courage to take it on.

Whatever the result, this is something we can look back on and feel genuinely proud of. We’re glad we gave ourselves the chance to do it. Cheers!

What we learned

One of the biggest things we’re taking away from this experience is how much we learned along the way. We learned how to use AI more systematically, from crafting better prompts to turning an idea into something that actually works. We also explored how multiple AI agents can work together, how to analyze errors instead of blindly trying to fix them, and how to approach debugging in a more structured way.

More importantly, we learned that building something good is not just about having a unique idea. It’s about questioning that idea, identifying its weaknesses, testing different approaches, and refining it until it becomes something more reliable. We also gained a better understanding of what it means to approach software development professionally, with proper planning, specifications, checklists, testing, and validation rather than just jumping straight into coding.

We still have a lot to learn, but this experience gave us a much clearer picture of how we want to approach building things in the future. Along with completing our first Devpost hackathon project before the deadline, that is something we’re genuinely proud of.

What's next for IncidentLens

Slack integration to analyze incident conversations directly from team discussions.
A deployed live version that teams can try on real incidents and use to generate evidence-based timelines, postmortems, and follow-up tasks.