All projects
Client & Production Projects

RootLine AI An internal tool that pulls bug tickets from the team's task board and uses an LLM to draft a root-cause analysis for each one.

A .NET backend that syncs bug tickets from ClickUp, assembles each one's full context for a Mistral model, and writes the generated root cause back to the ticket and into a dashboard used by QA and analysts.

an illustrated cover: bug ticket → ticket dashboard with root-cause column → AI analysis → posted to ticket

Client / Project

-

Industry

Internal tooling — software quality & QA analytics

My Contribution

  • Backend architecture (Onion) in ASP.NET Core
  • ClickUp integration & two-way sync
  • Mistral API integration & prompt design
  • Hangfire background processing
  • Angular dashboard (login
  • ticket table
  • filters)

The Brief

RootLine AI is an internal tool built to help a software team understand why its bugs happen, not just that they happened. It pulls bug tickets from the team's ClickUp board, gathers everything known about each one, and asks an LLM to draft a root-cause analysis — which then lands back where QA and analysts already work.

Built with: C#, ASP.NET Core, Entity Framework Core, MS SQL Server, Hangfire, Mistral API, ClickUp API, Angular, Power BI

Problem

Bug tickets carried plenty of information — descriptions, comment threads, status changes, linked tasks, attachments — but working out the underlying cause of each one was manual, slow, and rarely done consistently. Without it, QA and analysts could see what was breaking, but had little structured insight into why.

Solution

A .NET backend that treats root-cause analysis as a background pipeline. Bug tickets are synced from ClickUp, and for each one the service assembles the full context: the description, comments, status history, linked tasks, and attached files where present. That context is sent to a Mistral model with a prompt structured for root-cause reasoning, and the result is written back to the original ticket as a ClickUp comment and stored for the team's dashboard and Power BI reporting.

Key Features

An Angular dashboard lists synced tickets with their status and generated root cause. Tickets still being analyzed show a loading state until the result arrives. Filters narrow the list, and a manual sync pulls the latest changes from the board between scheduled runs.

Technical Approach

RootLine AI pipeline, from syncing ClickUp bug tickets to an LLM-generated root cause posted back to each ticket

  • Architecture: Onion Architecture, with the ClickUp integration and the AI integration each isolated in its own layer behind a single interface — so the rest of the system never depends on a specific board or model provider.
  • Backend: ASP.NET Core Web API with Entity Framework Core and MS SQL Server.
  • Background processing: two Hangfire workflows. One syncs tickets from ClickUp on a schedule or on demand and posts finished root causes back as comments. The other sends analysis requests to the Mistral API and waits for the results. Both keep slow external calls off the request path.
  • AI: direct integration with the Mistral API, with prompt structure and ticket-context formatting refined iteratively.
  • Frontend: Angular — login, the ticket dashboard, and a Power BI reporting page.

Challenges

Working with LLMs before the patterns existed

at the time, there were few established practices for integrating LLMs into products. Prompt structure and input formatting were worked out through deliberate iteration, comparing outputs against real tickets until the analyses became consistently useful.

Turning a ticket into usable context

a ticket's value is spread across its description, comments, status history, linked tasks, and attachments. Collecting and shaping all of that into a single input the model could reason about mattered more to the result than the prompt wording itself.

Slow external calls in a responsive product

both the ClickUp sync and model responses take time. Running them as Hangfire background jobs — with the dashboard showing progress per ticket — kept the application responsive.

Writing back safely

posting root causes into ClickUp meant every sync had to know what was already there. Each write checked for an existing analysis, so repeated syncs never duplicated comments, and the manual sync was disabled while one was already done or in progress.

My Role

Designed and built most of the backend: the Onion Architecture structure, the ClickUp and Mistral integration layers, the context-assembly and prompt logic, and the Hangfire background jobs. Also built the Angular dashboard and login. The team lead shaped parts of the architecture and reviewed the work throughout; the Power BI reporting was built by another frontend developer.

Conclusion

By handover, RootLine AI ran end to end: tickets synced from the board, analyzed in the background, and returned as root-cause comments on the tickets themselves, with the results feeding QA and analytics reporting. The project was also a practical lesson in LLM integration that still holds: the quality of the output depended less on the model than on how carefully the input was assembled.

Real products, practical engineering, and problems worth solving.

Selected work across .NET, full-stack SaaS, AI integrations, developer tooling, React, React Native, and more.

Get In Touch