Skip to main content
TL

Team quality platform

Ongoing

The 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+
Scattered errors converge into a central engine and come out sorted into records.

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

  1. 01

    Rescoping and rebuilding rather than taking over the existing app

    Problem

    The first version meets neither the original need nor the team's, and the team barely uses it.

    Solution

    Redefining the scope around the real need, then rebuilding and shipping a v1 to production in a week.

    Why this choice

    The 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.

  2. 02

    Building a knowledge base rather than an off-the-shelf tracker

    Problem

    The team has no error tracking, and products like Sentry would cover reporting and alerting.

    Solution

    In-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 choice

    Sentry 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.

  3. 03

    Recognising one error in its different forms

    Problem

    One cause can show up under several HTTP codes, and grouping too finely creates one record per variant of a single problem.

    Solution

    The 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 choice

    The 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.

  4. 04

    A generic agent platform rather than infrastructure per agent

    Problem

    Agents 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.

    Solution

    An 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 choice

    Build 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.

  5. 05

    Measuring the toolchain per repository and component rather than by tool count

    Problem

    The old metric validates a tool as soon as one report arrives, whatever the repository and component.

    Solution

    An 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 choice

    A 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.

Gallery