← All case studies

Live implementationHLD → LLD → Code

From business requirement to reviewed design and working code, with architects reviewing instead of writing.

Global consumer-goods manufacturer · integration delivery team · Live platform · name withheld

Days → hoursper design documentTargeted

100%of generated documents checked against standardsMeasured

3 + 3generator and validator agentsReported

The problem

Every new system connection at a global manufacturer needs a high-level design (HLD), a low-level design (LLD) and Azure integration workflows, each written to long governance standards and approved at architecture review.

£What it was costing them

Slow delivery of every integration, expensive senior time spent writing, and rework from failed reviews.

The existing workflow

How the work was done, and where it broke.

It starts with

A business requirements document (BRD) or a demand ticket is uploaded or fetched from Jira, Azure DevOps or Confluence.

What goes in

Requirements, ticket history and attachments, design templates, governance standards and published reference designs.

Done by hand today

Writing HLDs and LLDs by hand, manual standards checks and hand-coding integration workflows.

Weeks of design documents before any code was written.

Quality varied by author, so designs failed architecture review and came back.

Senior architects were the bottleneck on every project.

Standards documents were long and applied inconsistently.

The solution

Standards first, experts in charge. A named role approves every step.

1Encoded the standards

Turned the team's templates and governance rules into checks every document must pass.

2One agent per role

AI Solution Architect, Technical Designer and Integration Developer, each with a validator.

3Experts approve each step

The Solution Architect signs off the HLD, the Designer the LLD and the Developer the code.

4Fits the existing tools

Works from Jira, Azure DevOps and Confluence, and publishes back to them.

☺

Where a person decides

The Solution Architect approves the HLD, the Solution Designer the LLD, the Developer the code. Every step is reviewed by a role-based expert.

Architecture

From input to outcome.

Inputs

BRDs and demand tickets
Jira, Azure DevOps, Confluence
Templates and governance rules

Ingestion

Ticket, comment and attachment fetch
Document parsing
Reference design search

AI layer

Large language models, public or Azure cloud
Agent workflows on an agent framework

Agents and checks

HLD, LLD and Code generator agents
HLD, LLD and integration workflow validators
Architecture review eligibility check

Human review

Role-based approval: architect, designer, developer

Outcome

HLD and LLD published to Confluence
Integration workflow workflow code
Executive and admin dashboards

Integrations

Works with the systems already in place.

⇄

Confluence (fetch and publish)

⇄

Jira and Azure DevOps (tickets and attachments)

⇄

Azure integration workflows (code target)

⇄

Draw.io diagrams

Business value

What changed for the business.

Days to hours per documentTargeted

Agents draft the HLD, LLD and code; experts review rather than write.

Every document checkedMeasured

Each output runs through its validator before a person sees it.

One consistent standardReported

Designs come out in the same structure, whoever starts them.

Deployable codeReported

The pipeline ends in Azure integration workflows, not just documents.

The evidence

Shown on real work.

For each new system connection, Agent Foundry drafts the HLD with diagrams, the LLD to the team's standard and the integration workflow workflow, then checks all three against governance rules before the architect opens them.

About the evidence

The time saving is a design goal, not yet measured end to end. Confirm with the delivery lead before quoting.

How we label results