Team quality platform
OngoingThe team's errors, security toolchain and small tickets go through one tool, and a coding agent ships the simple fixes as pull requests.
- projects wired in
- 35
- error records
- 1 000+
- toolchain coverage
- 70 %
- PRs reviewed and tickets shipped by agents
- 40+

Context
- A developer hits an error a colleague already fixed. No tool keeps the cause or the fix, so the developer asks around or starts from scratch.
- The team tracks its errors poorly. No tool centralises them, and on several projects some run in production for months unnoticed.
- The security toolchain compliance metric counts published tools, with no split by repository or component.
- A first version exists. It starts from another need, drifts toward a knowledge base and covers neither. The team barely uses it.
My mission
- Redefining the scope around the team's real need.
- Designing and building the platform end to end, NestJS backend and React frontend.
- Defining the error ingestion contract, shared by every stack.
- Azure DevOps sync: one ticket per intervention, regression detection, a daily report on Teams.
- Designing a coding-agent platform on Azure Container Apps Jobs, in read-only or write-and-verify mode. The platform is still in its build phase.
- Setting up the Azure DevOps delivery pipeline, with Sonar analysis, Fortify SAST and dependency checks.
- Weekly updates to the teams and feedback collection to remove friction.
Decisions and trade-offs
01
Rescoping and rebuilding rather than taking over the existing app
ProblemThe first version meets neither the original need nor the team's, and the team barely uses it.
SolutionRedefining the scope around the real need, then rebuilding and shipping a v1 to production in a week.
Why this choiceThe problem lies in the scoping more than in the code. Taking over the existing app would carry the wrong scope forward. Since then, on projects blind for months, the team fixes errors within days, and the flow drops from several errors a day to one a week, at equal usage.
02
Building a knowledge base rather than an off-the-shelf tracker
ProblemThe team has no error tracking, and products like Sentry would cover reporting and alerting.
SolutionIn-house ingestion and grouping of errors into records. The team fills in each record's cause and fix by hand, and each intervention opens its own Azure DevOps ticket.
Why this choiceSentry reports events. The team wants to maintain knowledge: cause, fix, reference answer per project. A fixed error that comes back reopens a ticket with the previous diagnosis. In exchange, the team designs and maintains the grouping and the rules itself.
03
Recognising one error in its different forms
ProblemOne cause can show up under several HTTP codes, and grouping too finely creates one record per variant of a single problem.
SolutionThe fingerprint groups by project, context (route or operation) and exception type, without the status code. Per-project regex rules normalise the context, with a merge preview before applying.
Why this choiceThe status code varies without changing the problem. Including it would split one cause into several records. Each project's rules then tune the grouping level. In exchange, a retroactive merge cannot be undone.
04
A generic agent platform rather than infrastructure per agent
ProblemAgents keep coming: Sonar hotspots, pull request review, Azure DevOps tickets, architecture docs, authorization matrix. Each one needs a cloned repository, tools and an isolated environment.
SolutionAn agent becomes a backend recipe: prompt, mode, verification. Jobs go through one queue and one Container Apps Jobs image per toolchain. In write mode, the worker records build and tests before the change, and refuses the push if passing tests drop.
Why this choiceBuild and test verification needs the toolchain inside the image, and a Storage Queue cannot filter its messages. One queue and one image per toolchain settle both constraints, and a new agent costs one recipe. In exchange, every new toolchain needs its own queue and job.
05
Measuring the toolchain per repository and component rather than by tool count
ProblemThe old metric validates a tool as soon as one report arrives, whatever the repository and component.
SolutionAn agent reads each repository's pipelines and manifests and builds the expected inventory: repository, component, tool. The backend rereads the wired pipelines every night, and the score counts covered cells. An admin adds or disables a cell, with a mandatory reason.
Why this choiceA single report says nothing about the coverage of a repository with front, back and libraries. The agent only does discovery, and a deterministic reread of the pipelines confirms its verdict. In exchange, the team fixes the agent's reading gaps by hand.
What this project taught me
- Taking over an internal product and rescoping it around the real need before writing a line.
- Driving the adoption of a cross-team tool through weekly updates and regular feedback loops.
- Co-designing the ingestion contract with the experts of the stacks outside my scope.
- Growing an error tool into a DevSecOps platform, at the pace of the team's needs: toolchain, Sonar and Dependency-Track findings, tickets, pull request reviews.
- Running coding agents in production with guardrails: build and test verification, human-reviewed pull requests, a dedicated Azure DevOps identity.
- Using AI tools to speed up design and focus my attention on code review and security.