AWS Builder Center

Building RegImpact: An Evidence-Grounded Regulatory Intelligence Platform for Indian FinTechs

An AWS-powered, evidence-grounded regulatory intelligence platform that transforms RBI regulations into company-specific compliance gaps, risk assessments, and actionable remediation.

From Financial Controls to Regulatory Intelligence

During my internship as a Summer Analyst in the Controller Division at Goldman Sachs, I saw how important traceability and evidence are when working with financial information.
A number can look correct, but in a financial environment, that is not enough. You need to understand where it came from, what process produced it, and what evidence supports it.
That experience influenced how I approached a different problem: regulatory compliance.
For financial institutions, regulations are continuously updated and can span lengthy circulars, notifications, and guidelines. The difficult part is not simply finding a regulation or asking an AI model what it says.
The difficult question is:
“This regulation changed. What does it actually mean for our company?”
A compliance team may need to determine whether a requirement applies to the organization, find evidence in internal policies, identify gaps, assess the associated risk, and decide what needs to be done next.
That process inspired us to build RegImpact, an RBI-first regulatory intelligence platform designed to turn regulatory documents into company-specific compliance actions.
The goal was not to build another chatbot that answers questions about PDFs.
The goal was to build a system that can follow the chain:
Regulation → Applicability → Requirement → Evidence → Gap → Risk → Action



The Problem

Consider a payment aggregator operating in India.
The Reserve Bank of India publishes a new circular containing dozens of requirements.
A compliance team now needs to answer questions such as:
  • Which requirements apply to the company?
  • Which internal policies provide evidence of compliance?
  • Where are the gaps?
  • Which gaps require immediate attention?
  • What needs to be changed?
  • Who should be responsible for fixing it?
  • Which regulatory source supports the conclusion?
A conventional document search system can answer:
“What does this circular say?”
But that is only the beginning.
A useful compliance system needs to answer:
“What does this circular mean for this particular company?”
That distinction shaped the architecture of RegImpact.



From Regulatory Documents to Company-Specific Impact

We designed RegImpact around a structured reasoning pipeline.
Official Regulatory Sources
↓
Regulatory Corpus
↓
Hybrid Retrieval
↓
Applicability Analysis
↓
Requirement Extraction
↓
Company Evidence
↓
Gap Analysis
↓
Risk Assessment
↓
Remediation Actions
↓
Evidence Verification

Instead of allowing a single LLM prompt to produce a final answer, we split the workflow into multiple stages.
This gives us better traceability and allows deterministic business rules to remain outside the language model.



Why RAG Alone Wasn't Enough

One of our first architectural questions was:
Why not simply use RAG?
A standard RAG application looks roughly like:
Question
↓
Embedding
↓
Vector Search
↓
Relevant Chunks
↓
LLM
↓
Answer

This works well for document question answering.
Compliance analysis is different.
The system needs to reason about relationships between several types of information:
Regulation
↓
Requirement
↓
Company Profile
↓
Company Evidence
↓
Compliance State
↓
Risk
↓
Remediation

Finding a regulatory statement is only the beginning.
The system also needs to determine whether that statement applies to the company and whether the company's internal evidence actually demonstrates compliance.
This is why we designed RegImpact as a reasoning workflow around RAG, rather than treating RAG as the entire application.



Building the Regulatory Corpus

Another important design decision was to avoid making regulatory-document upload the primary workflow.
For the RBI-first version of the platform, regulatory documents are collected from official sources and maintained as a regulatory corpus.
Conceptually:
RBI
↓
Document Discovery
↓
Document Download
↓
Metadata + Version
↓
Text Extraction
↓
Chunking
↓
Embeddings + Full Text Index
↓
RegImpact Corpus

Each document can be associated with metadata such as:
  • regulator
  • document type
  • publication date
  • effective date
  • circular/reference number
  • source URL
  • version information
This allows the system to reason over regulations as a maintained knowledge base rather than as isolated PDFs.
The architecture is intentionally RBI-first rather than RBI-only. The underlying reasoning engine can support other regulatory domains while the initial regulatory intelligence layer focuses on Indian financial regulation.



Hybrid Retrieval

We did not want to rely exclusively on vector similarity.
Regulatory documents contain many things that are important to retrieve exactly:
  • circular numbers
  • section numbers
  • dates
  • defined terms
  • policy names
  • regulatory terminology
  • specific phrases
Pure semantic search can miss some of these details.
Therefore, RegImpact combines:
Semantic retrieval + PostgreSQL full-text search
The results are then combined using reciprocal rank fusion.
Conceptually:
Regulatory Query
|
+---------+---------+
| |
Vector Search Full Text Search
| |
+---------+---------+
|
RRF
|
Relevant Evidence

This gives the system both semantic matching and exact textual retrieval.



Company Evidence Matters

One of the design principles we adopted was:
A checkbox is not evidence.
A company profile may indicate that an organization has a particular security policy.
That does not prove that the policy exists or that it satisfies a particular regulatory requirement.
Therefore, RegImpact supports company evidence such as internal policy documents.
The reasoning process becomes:
Regulatory Requirement
↓
Does it apply?
↓
Find company evidence
↓
Does the evidence satisfy the requirement?
↓
Compliant / Partial / Gap / Uncertain

This distinction is important because compliance systems should not manufacture certainty from missing evidence.
If the system cannot find sufficient evidence, uncertain or needs review can be a legitimate result.



Agent-Based Analysis

We divided the analysis workflow into several stages rather than asking one model to perform everything.
The workflow includes:
  1. Applicability
  1. Requirement extraction
  1. Impact analysis
  1. Gap detection
  1. Risk assessment
  1. Action planning
  1. Evidence verification
Each stage has a defined input and output contract.
For example:
Requirement
+
Company Profile
↓
Applicability Analysis
↓
Applicable / Not Applicable / Uncertain

Then:
Applicable Requirement
+
Company Evidence
↓
Impact Analysis
↓
Compliant / Partial / Gap / Uncertain

And finally:
Gap
↓
Risk Assessment
↓
Remediation Action

This decomposition makes the system easier to test, debug, and reason about.



Where AI Ends and Deterministic Logic Begins

One of the most important architectural decisions was deciding what not to give to the LLM.
We use AI where language understanding and interpretation are necessary.
For example:
  • interpreting regulatory language
  • extracting requirements
  • comparing requirements with policy evidence
  • generating remediation explanations
  • producing human-readable summaries
But we keep important system behavior deterministic.
Examples include:
  • schema validation
  • company-scope rules
  • evidence constraints
  • risk calculation
  • workflow state
  • document versioning
  • database operations
The principle is:
Use AI for reasoning over language. Use deterministic software for rules that must behave predictably.
This makes the system easier to evaluate and reduces the amount of critical business logic hidden inside model outputs.



Evidence-Grounded Outputs

Every meaningful compliance conclusion should be traceable back to evidence.
Instead of simply producing:
“The company is compliant.”
RegImpact aims to produce something closer to:
Requirement
↓
Regulatory Citation
↓
Company Evidence
↓
Analysis
↓
Compliance State
↓
Risk
↓
Recommended Action

This makes the output more useful to a compliance professional because the system is not simply asking them to trust an AI-generated answer.
They can inspect the evidence behind the conclusion.
This was one of the principles I carried over from my experience in financial controls:
The conclusion matters, but the trail supporting the conclusion matters just as much.



Risk Should Not Be an LLM Guess

Another important design choice was separating risk calculation from free-form model output.
The LLM can help identify the nature and severity of an issue, but the final risk logic can be governed by deterministic rules.
For example:
Impact
+
Likelihood
+
Regulatory Criticality
↓
Risk Level

This prevents the model from arbitrarily deciding that an issue is “high risk” simply because its generated explanation sounds severe.
The model contributes interpretation.
The application owns the rules.



AWS Architecture

We designed the system around AWS services so that different components could scale independently.
A simplified architecture looks like this:
CloudFront
|
Frontend
|
ALB
|
FastAPI Application
|
+------------+------------+
| | |
PostgreSQL S3 SQS
+ pgvector | |
| Worker
| |
+------------+
|
AI / Analysis

The major components include:

Amazon S3

S3 provides durable object storage for regulatory documents and company evidence.
This prevents uploaded documents from being tied to the lifecycle of application containers.



PostgreSQL + pgvector

PostgreSQL is used for structured application data as well as vector retrieval through pgvector.
It stores information such as:
  • regulatory metadata
  • company information
  • compliance findings
  • actions
  • embeddings
  • retrieval metadata
Keeping the structured data and retrieval layer close together simplifies the architecture.



Amazon SQS

SQS is used to decouple longer-running processing jobs from the API.
For example:
User uploads document
↓
API
↓
SQS
↓
Worker
↓
Extract → Chunk → Embed → Index

The API does not need to remain blocked while a document is processed.
This also gives us a cleaner path toward scaling ingestion independently from user-facing requests.



Amazon ECS / AWS Fargate

The API and background worker can run as independent containers.
This separation is particularly useful because document ingestion and AI analysis can be considerably more resource-intensive than ordinary API requests.



AWS Secrets Manager

Sensitive configuration such as database credentials should not be embedded inside source code or container images.
Secrets can instead be managed separately and injected into workloads at runtime.



Amazon CloudWatch

CloudWatch provides logging and operational visibility for the application and background workers.
For an AI workflow, observability becomes particularly important because failures can occur at several stages of the pipeline rather than at a single API endpoint.



Specification-Driven Development

One part of the project that I particularly wanted to get right was the development process itself.
We treated specifications as part of the engineering workflow rather than something written after implementation.
The project contains numbered specifications covering areas such as:
  • product definition
  • system architecture
  • input contracts
  • database design
  • AWS deployment
  • security
  • API contracts
  • frontend
  • document ingestion
  • RAG
  • agent contracts
  • orchestration
  • impact analysis
  • evidence verification
  • testing and evaluation
The development flow became:
Product Requirements
↓
Specifications
↓
Schemas + Contracts
↓
Architecture
↓
Implementation
↓
Tests

This was particularly useful for an AI system because agent behavior can otherwise become difficult to control.
Instead of:
“Let the agent figure it out.”
we define:
  • what an agent receives
  • what it is responsible for
  • what it should return
  • what constraints apply
  • how its output is validated
This makes the AI layer behave more like a software component and less like an uncontrolled black box.



Designing for Human Review

Regulatory compliance is not a domain where we wanted the system to pretend it is infallible.
There are situations where the correct result is:
Uncertain.
For example:
  • the regulation is ambiguous
  • evidence is missing
  • multiple interpretations are possible
  • the company profile does not provide enough information
In these situations, the system should surface uncertainty instead of forcing a confident answer.
This leads to an important design principle:
Human review should be a feature, not a failure state.
The objective is to reduce repetitive analysis while keeping humans responsible for important compliance decisions.



Regulatory Change Detection

A natural extension of the architecture is regulatory change detection.
Instead of waiting for someone to discover that a regulation has changed, the system can periodically check official regulatory sources.
The conceptual workflow becomes:
New RBI Publication
↓
Change Detection
↓
Affected Requirements
↓
Affected Companies
↓
Existing Evidence
↓
New Gaps
↓
Risk
↓
Remediation

This changes the role of the platform.
It becomes more than a document analysis application.
It becomes a regulatory intelligence workflow that can help organizations understand what changed and what they need to do about it.



What I Learned Building It

Building RegImpact highlighted several lessons about designing AI systems for real-world workflows.

1. RAG is not the product

Retrieval is infrastructure.
The product is the workflow built around the retrieved information.
A vector database by itself does not answer whether a company has a compliance gap.



2. More agents do not automatically mean a better system

It is tempting to keep adding agents.
But additional agents also introduce:
  • more failure points
  • higher latency
  • more difficult debugging
  • more complex evaluation
The important question is not:
“How many agents do we have?”
It is:
“Does each stage have a clearly defined responsibility?”



3. Evidence is more useful than artificial confidence

An AI system saying that it is “95% confident” does not make the underlying conclusion correct.
For compliance workflows, being able to show:
why the system reached the conclusion and what evidence supports it
is much more valuable.



4. AI and deterministic software should complement each other

LLMs are extremely useful for interpreting language.
They are not necessarily the right place to implement every business rule.
Keeping deterministic logic around important decisions makes the overall system easier to test and reason about.



5. Architecture should follow the workflow

We did not start by choosing a collection of AWS services and then trying to find a use for them.
We started with:
What does a compliance analyst actually need to do?
Then we designed the workflow and selected infrastructure around it.
That approach helped us avoid adding technology simply because it was available.



What Comes Next

The current architecture provides a foundation for expanding beyond the initial RBI use case.
Potential improvements include:
  • broader RBI source coverage
  • additional Indian regulators such as SEBI and IRDAI
  • improved regulatory version comparison
  • continuous regulatory monitoring
  • stronger evaluation datasets
  • more sophisticated evidence linking
  • organization-specific compliance dashboards
  • human approval workflows
  • improved model evaluation
  • deeper observability for AI decisions
The long-term direction is not to replace compliance professionals.
It is to reduce the amount of repetitive document analysis they have to perform and give them a structured, evidence-backed starting point for their decisions.



Conclusion

RegImpact started with a simple observation:
Reading a regulation is not the same as understanding its impact on a company.
My experience in the Controller Division at Goldman Sachs reinforced how important traceability and evidence are when working with financial information. That perspective influenced the way we designed RegImpact: the system should not simply generate an answer, but provide a path from the regulatory source to the evidence, reasoning, risk, and resulting action.
Building an effective regulatory intelligence system therefore requires more than an LLM and a vector database.
It requires:
  • reliable regulatory sources
  • structured retrieval
  • company-specific evidence
  • controlled AI reasoning
  • deterministic business rules
  • traceability
  • human review
  • and infrastructure capable of processing the workflow reliably
AWS provides the infrastructure needed to bring those components together into a scalable system.
The biggest lesson for me was that the value of an AI system does not come from making the model do everything.
It comes from designing the right system around what the model is actually good at.
Regulation → Evidence → Reasoning → Action.
That is the workflow we built RegImpact around.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article