ShebaShathi BD is a Bangla-first, source-grounded guide to citizen services._
Public information should be usable without a middleman.
The Problem
The information is public — but it is not usable.
Public information in Bangladesh is published across ministry portals, PDF notices, hotline pages and circulars.
The real problem is that it is written for the institution, not the citizen.
A parent applying for a child's passport must work out:
- whether the child needs an NID
- which guardian documents apply
- which photo specification matters
- what the real fee is
The answer exists, but it is scattered, technical and hard to verify.
So people ask someone who claims to know. That is where middlemen, wrong fees and unnecessary document requests enter the process. Sometimes people share identity details just to receive an answer that was already public.
The citizen should not have to pay for clarity.
That was the starting point for ShebaShathi BD.
The Solution
A guide before the portal — not another portal.
ShebaShathi BD is an independent, Bangla-first guide for five citizen services:
A person describes their situation in Bangla, English or Banglish and receives a clear checklist with the documents, steps, fees and official links that apply to them.
Equally important is what the product does not do:
- It does not submit applications
- It does not authenticate people or documents
- It does not store identity numbers
- It does not pretend to be a government service
- It does not let a language model decide facts
A guide, not a gatekeeper.
The Core Principle
AI explains. Code decides. Sources prove.
This one rule shaped the entire architecture.
Fees, checklists, eligibility and routing are deterministic. They come from validated data files with a source URL and a verification date.
The language model has a narrow job:
- classify the request
- explain retrieved material in plain language
It is never allowed to choose a fee, invent a document or add a deadline.
The rule can be written as a simple condition:
$$ \text{grounded}(a) = \begin{cases} \text{show } a, & \text{if every number in } a \text{ appears in } S \ \text{deterministic fallback}, & \text{otherwise} \end{cases} $$
where ( a ) is the generated answer and ( S ) is the retrieved source set.
The model can explain the answer. It cannot invent the answer.
How It Works
Understand → retrieve → verify → explain.
1. Understand
The citizen describes their situation in their own words.
2. Route
The request is mapped to a service and task. If no model key is configured, the provider fails, or the output is invalid, a deterministic keyword router takes over. The product still works.
3. Protect
Identity-like numbers are rejected before any model call.
4. Retrieve
Answers come from a curated, service-scoped corpus. One authority's content cannot silently answer another service's question.
5. Verify
Before anything is shown, a verifier checks the generated response against the retrieved sources. If the model introduces an unsupported number, the generated answer is replaced by the deterministic summary.
6. Explain
The final answer is written in plain Bangla or English, with citations, verification dates and source references.
Unknown cases get an official link — not a confident guess.
Privacy by Design
The most sensitive tools never leave the browser.
Several features normally require uploading personal data. In ShebaShathi BD, they run locally:
- Fee comparison
- Complaint drafting
- Document consistency checking
- PDF text extraction
- Bangla voice input
The complaint draft is generated from deterministic templates in the browser. Voice input uses a self-hosted Whisper model, not the browser speech API, because that API streams audio to a remote recogniser.
Document values are never uploaded, stored or logged.
Privacy is an architecture decision — not a policy sentence.
How I Built It
Small layers, strict boundaries.
Frontend: Next.js and Tailwind, with Bangla as the default language, not a translation layer.
Backend: FastAPI, with retrieval over a service-filtered multilingual corpus.
Data layer: versioned service files, fee schedules and corpus documents, each with a source and a verification date, plus a verification log.
A simplified version of the data contract looks like this:
{
"service_id": "epassport",
"source_url": "https://www.epassport.gov.bd/",
"last_verified": "<verification date>",
"documents": ["<verified document>"],
"steps": ["<verified step>"],
"fee_schedule": "<verified fee reference>"
}
I built the product in layers:
- first the deterministic e-Passport guide and fee logic
- then the shared service contract
- then retrieval and citations
- then the copilot and AI case brief
- finally the local-only tools
Each layer had to preserve the same rule: no feature could make an unverified fact easier to display.
The failure paths are part of the product.
The Challenges
The hard part was not adding AI. It was making AI safe to trust.
Making grounding real, not decorative
It is easy to add citations. It is harder to guarantee that an answer only says what the citations support.
The verifier, the deterministic fallback and the service-scoped retrieval filter were built to close that gap.
Getting retrieval to work in production
A startup warmup created the cached embedder and vector client on a worker thread, then reused them from the request thread. Retrieval returned nothing while the health endpoint still reported a populated index.
The fix was to perform the warmup on the startup event loop.
The index can be full while the query still returns nothing.
Fitting inside a free-tier deployment
The production backend had a hard memory ceiling and very limited CPU. The default PyTorch embedding path was too heavy.
I added an ONNX int8 embedder and a lightweight exact-search vector store for serving, while keeping the development path unchanged. I verified retrieval parity against the evaluation set before trusting the change.
Bangla rendering
Bangla shaping is not a font afterthought.
Browser print-to-PDF with a locally served Bangla font produced better results than adding a JavaScript PDF library, and it kept the dependency surface smaller.
Privacy versus convenience
The easiest version of complaint drafting and document checking sends everything to a server.
That would have broken the product's central promise.
Moving those workflows into the browser cost more engineering, but it made the privacy claim architectural, not just a policy statement.
What I Learned
Trust is an engineering property.
I learned that trust is not a tagline added at the end. It comes from:
- deterministic boundaries
- visible sources
- honest fallbacks
- predictable behaviour when the model is unavailable or wrong
I also learned that Bangla-first is not only translation. It changes typography, line length, voice input, PDF export and the way explanations are structured.
Designing for the default user, not the English-speaking edge case, made the product better for everyone.
A civic tool that says “I do not have a verified answer” is more useful than one that always sounds confident.
What's Next
Grow trust before growing coverage.
The next step is not to add more services for the sake of coverage.
It is to:
- deepen verification
- test with Bangla-first users
- work with community help desks so the guide reaches people at the moment they need it
Service coverage should grow only where official sources can be checked and dated.
Closing
ShebaShathi BD — built for AIgnite 2026.
Built With
- chromadb
- docker
- fastapi
- hugging-face-transformers
- i18next
- multilingual-e5-small
- next.js
- noto-sans-bengali
- numpy
- onnx-runtime
- openai-compatible-api
- openrouter
- pdf.js
- pydantic
- python
- react
- render
- retrieval-augmented-generation-(rag)
- tailwind-css
- tesseract.js
- typescript
- vercel
- vitest
- whisper