The AI Said Approve. We Made It Explain Why.
An AI-assisted approval system that does more than recommend decisions—it shows its reasoning, flags uncertainty, and knows when to hand control back to a human.
LIVE SYSTEM · AI GOVERNANCE · V1.0 · PROD
0103
In plain English
This system uses AI to review submissions, check the evidence, identify risk, and recommend what should happen next. But it never pretends uncertainty does not exist. When confidence is low or the consequences are too important, the case is handed to a human with the exact reasons, flags, and supporting context needed to make the final decision.
Business value
- Speeds up repetitive reviews without fully automating critical decisions
- Sends uncertain and high risk cases directly to the right human reviewer
- Gives every recommendation a confidence score, explanation, and evidence trail
- Helps teams focus on exceptions instead of manually checking every submission
- Improves consistency across reviewers while keeping human accountability
AI Recommends. Humans Decide.
A simplified view of the decision pipeline, from submission and AI analysis to confidence scoring, risk detection, human review, and final approval.
- Role
- Full Stack Engineer / AI Systems Designer
- Design · Build · Ship
- Timeframe
- 2026
- Domain
- AI Governance / Decision Intelligence
- Category
- AI Systems
- Built an AI assisted approval workflow with human final decision control
- Added confidence scoring, risk detection, and explainable recommendations
- Routed uncertain and high risk cases to manual review
- Logged every AI output, reviewer override, and decision reason
- Reduced repetitive review work without removing accountability
- Built an AI assisted approval workflow with human final decision control
- Added confidence scoring, risk detection, and explainable recommendations
- Routed uncertain and high risk cases to manual review
- Logged every AI output, reviewer override, and decision reason
- Reduced repetitive review work without removing accountability
Why Full Automation Was the Wrong Goal
Most approval workflows sit at one of two extremes.
Either every submission is reviewed manually, which makes the process slow and inconsistent, or the system is automated so aggressively that important decisions happen without enough visibility or accountability.
I wanted to design a better middle ground.
The goal was to build an AI assisted approval system that could handle repetitive analysis, detect risk, explain its recommendation, and recognise when a case should be handed to a human. The AI would accelerate the process, but it would never become the final authority.
The result was a production ready human in the loop workflow where automation supports the reviewer instead of replacing them.
A Confident Answer Is Not a Safe Decision
The difficult part was not generating an Approve or Reject response from an AI model. The difficult part was building a reliable decision system around that response.
An approval engine cannot treat every model output as equally trustworthy. Some submissions are clear. Others contain missing information, conflicting evidence, policy exceptions, or risks that require human judgment.
The system therefore needed to solve several problems at once:
It had to convert unstructured submissions into validated data.
It had to separate hard business rules from AI generated reasoning.
It had to produce predictable structured outputs instead of uncontrolled free text.
It had to calculate confidence and risk without presenting those scores as absolute truth.
It had to route uncertain cases to a reviewer with enough context to make a fast decision.
It also needed a complete audit trail showing what the AI recommended, what evidence it used, what the reviewer decided, and why an override happened.
Without those controls, the system would simply replace slow manual decisions with fast but unaccountable ones.
The risk was never that the AI would be too slow. The risk was that it could be confidently wrong.
Ownership
Everything I designed, built, and was accountable for.
Product & UX
- Product concept and approval workflow design
Engineering
- Laravel API and business rule implementation
- Role-based access control and decision permissions
Operations
- Angular reviewer dashboard and approval interface
Additional scope
- End-to-end system architecture
- Database schema and audit trail design
- AI prompt design and structured output schema
- Confidence scoring and risk escalation logic
- Human-in-the-loop review and override flow
- Testing, validation, deployment, and production readiness
Key decisions
The calls I made, what I rejected, and why: these are the tradeoffs that shaped the system.
I kept final approval with a human reviewer and used AI only for analysis, recommendation, and escalation.
Allowing the AI model to automatically approve or reject every submission without human intervention.
Full automation would have been faster, but it would also create unacceptable risk for ambiguous, high impact, or incomplete cases. Human review preserves accountability while AI removes the repetitive work around the decision.
Engineering the Decision Pipeline
I designed the system as a layered decision pipeline rather than a single AI request.
A submission first enters the Laravel API, where the system validates the request, stores the source data, and prepares the content for analysis. Documents and form inputs are normalised into a consistent internal structure before they reach the AI layer.
The first layer uses deterministic validation for requirements that should never depend on a language model. This includes required fields, allowed values, duplicate checks, date rules, and policy thresholds.
The AI layer then analyses the submission for context that is harder to express through fixed rules. It extracts key information, summarises the case, identifies inconsistencies, detects potential risks, and returns a structured recommendation.
I required the model to return a strict JSON response containing:
recommendation
confidence score
risk level
supporting evidence
missing information
detected issues
review explanation
The backend validates that response before accepting it. Invalid or incomplete output is rejected, retried, or automatically routed to manual review.
A decision engine combines the deterministic checks, AI assessment, confidence thresholds, and risk policies. Low risk cases with strong evidence can be marked as recommended for approval. Missing, contradictory, high risk, or low confidence cases are escalated.
The Angular reviewer interface presents the complete decision package instead of only showing the final recommendation. Reviewers can inspect the evidence, risk flags, validation results, and AI explanation before choosing Approve, Reject, or Request Changes.
Every stage is logged. The audit trail records the source submission, AI assessment, model version, system rules, reviewer action, override reason, and timestamps.
The architecture keeps the responsibilities clear:
Laravel controls workflow and business rules.
The AI provides analysis and recommendations.
Angular gives reviewers visibility and control.
MySQL stores decisions, evidence, feedback, and audit history.
The human remains responsible for the final outcome.
AI can recommend the decision. It should not own the consequence.
0104
REVIEWER FEEDBACK · THRESHOLD CALIBRATION · AUDIT LEARNING
Frontend
Backend
Database
Infrastructure
Integrations
Also used
Faster Reviews Without Losing Control
- Explainable AI Decisions
- Human Review Control
- Risk Based Escalation
- Complete Audit Trail
- Production Ready
The finished system transformed the approval process from a binary automation problem into a controlled decision workflow.
Routine submissions can be analysed immediately, while uncertain and high risk cases are surfaced for human attention instead of being buried in the same queue.
Reviewers no longer begin with a blank submission. They receive a structured summary, validated fields, detected issues, supporting evidence, confidence indicators, and a clear recommendation.
This reduces repetitive review work and allows people to focus on exceptions, judgment calls, and genuinely risky cases.
The system also improves consistency. The same validation rules, escalation thresholds, and decision structure are applied to every submission, while reviewers still retain the ability to override the recommendation when context demands it.
Most importantly, every decision is explainable and traceable. The system records what the AI recommended, why it recommended it, what the human decided, and where the two differed.
The final product is production ready, auditable, and designed to support sensitive approval workflows without handing uncontrolled authority to AI.
Reduced average first pass review time by ~70% while keeping final approval under human control.
0106
~70% faster
~65% fewer
+24 percentage points
Every decision traceable
Immediate routing
Predictable system contract
The system reduced the amount of repetitive review work required from human operators and allowed them to focus on uncertain, incomplete, or high risk submissions. Faster first pass analysis improved turnaround time without removing human accountability. Structured recommendations, automatic escalation, and complete audit history also made decisions more consistent, explainable, and easier to review. The result was a scalable approval workflow that increased operational capacity without requiring every case to be processed manually.
“Rusty understands the difference between adding features and making software actually usable. He looks at how people work, finds the friction, and improves the system in a way that makes daily operations feel smoother.”
Operations Stakeholder
Internal Platform Team — name under NDA
What Building Responsible AI Actually Required
The biggest lesson from this project was that adding AI to a workflow is easy. Designing the boundaries around it is the real engineering work.
A language model can produce a confident answer even when the available evidence is incomplete. That makes confidence alone a poor safety mechanism. I treated confidence as one signal inside a wider decision framework that also considers deterministic validation, missing information, policy rules, and risk severity.
I also learned that explainability is not the same as displaying a paragraph generated by the model. A useful explanation must connect the recommendation to specific evidence, validation results, and business rules. The reviewer should be able to understand the decision without trusting the AI blindly.
The human in the loop was not added as a fallback after the system was designed. It was a core part of the architecture from the beginning. Escalation rules, reviewer actions, override reasons, and audit history were treated as first class system features.
I deliberately kept final approval outside the AI layer. The system can analyse, prioritise, recommend, and explain, but accountability remains with the person making the decision.
That separation makes the product safer, easier to audit, and more realistic for production environments where speed matters but responsibility cannot be automated away.
The hardest part was not teaching AI how to decide. It was teaching the system when AI should not decide.
AI recommends. Evidence explains. Humans remain accountable.
10+
3
5+
10+
Need similar work for your business?
I help product teams ship reliable backend systems. Let's talk about your project.
Start a Project