Product Roadmap — From Statement Tool to Underwriting Workspace

Living document. Last meaningful update: 2026-06-23. Owner: Salil. Strategy: ../strategy.md · Market: ../go-to-market/market-analysis.md · Feature inventory + build status: features.md · Pricing: pricing.md

This doc is the forward view (what to build next and why). features.md is the current view (what exists). When something here ships, move it there.

The thesis in one line

Obsrv today processes a statement. Our customer’s job is to underwrite a borrower. The platform is closing that gap — making the Borrower Case the unit of the product, and owning the underwriting workflow that wraps it.

Why the unit matters (the reframe)

• The market is priced per borrower, not per page. Precisa = ₹100 per account, up to 12 statements. Ocrolus sells “cash-flow analytics for lenders.” We are the only one priced per page — and market-analysis.md flags ₹5/page as ~3.6× too expensive for a real 6-month underwriting pull. The pricing fix and the platform move are the same move.
• A borrower has multiple statements (6–12 months, often 2–3 accounts/banks). Today that’s N disconnected jobs and N disconnected reports. No one can answer “what is this borrower’s consolidated income and FOIR?” in one click.
• So “what feature next?” is really “what workflow?”.

The workflow we own

Collect  →  Verify it's real  →  Consolidate  →  Decide  →  File / Audit
(intake)    (tamper)            (Borrower Case)  (policy)   (decision packet)

We now own most of this arc: Verify (dual reconciliation gate), Consolidate (Borrower Case), and Decide (eligibility + approve/refer/decline against the lender’s policy, with a delegated-authority override queue) — plus a first slice of File / Audit (append-only decision trail + CSV export). The open ends are the bookends: Collect (intake link / AA) and the fuller decision-packet PDF, plus Verify’s tamper layer. The remaining build is case as the primary decision unit (decisions run on the consolidated case, not per statement).

The ranked roadmap

Status: ✅ built · 🟡 partial · 🔲 not started Tier: Spine = the platform primitive · Trust = on-brand differentiator · Workflow = extends the arc · Later = post-PMF

1. Borrower Case — multi-statement consolidation · ✅ built (Phase 1 + 2) · Spine

One object holding N statements across months / accounts / banks, consolidated into a single financial picture: combined income, inter-account transfer dedup (don’t double-count money the borrower moves between their own accounts), consolidated FOIR, one reconciled risk view.

• Why first: it’s the platform primitive that unlocks everything else. Reframes Obsrv from a tool into a workspace. (Pricing is settled separately — credit packs, not a per-borrower bundle; see pricing.md.)
• On-brand edge: consolidation done verifiably: auditable dedup and reconciliation across accounts and overlapping periods, every netted transfer tracing back to its source rows.
• Hard part: cross-account transfer matching; overlapping/!contiguous statement periods; one risk score over a merged ledger without losing per-account auditability.
• Unlocks: case-level decisions (the next build), intake link, decision packet.
• Supersedes parked task: Multi-statement cases (multi-month / multi-account).
• Deep-dive design: borrower-case.md — data model, the inter-account dedup algorithm, overlapping-period handling, consolidated FOIR/scoring, and a two-phase rollout.

2. Tamper / authenticity detection · 🔲 · Trust

Deterministic forensics on each document before it enters a Case: PDF metadata / producer chain, font & object inconsistencies, recomputed-balance tampering, OCR-layer-vs-text mismatch, digital-signature validation.

• Why high: the fastest-growing battleground — AI document fraud up ~5×; bank statements are 59% of flagged fraud docs. It is the #1 gap on our own scorecard (Precisa, Perfios, Ocrolus, Inscribe all have it; we don’t).
• On-brand edge: it’s a trust feature, and deterministic forensics sit squarely in our “verifiable, reproducible” lane — the one story no competitor tells.
• Placement: the “Verify” step inside a Case — prove every document is real before consolidating. Strong standalone premium signal too.

3. Borrower intake link · 🔲 · Workflow

A shareable, secure link the lender sends the borrower: “upload your last 6 months.” Borrower uploads (AA-connect later) → an assembled Case lands in the lender’s workspace.

• Why: solves the real-world mess of collecting PDFs over WhatsApp / email. The front of the workflow, and a borrower-facing touchpoint = brand + light virality.
• Depends on: Borrower Case (somewhere to assemble into).

4. Policy / decision-support layer · ✅ (calibration 🟡) · Workflow

The lender encodes their credit policy (min avg income, max FOIR, zero bounces in 90 days, min ADB, …) and gets a recommendation — Approve / Approve-with-conditions / Counter-offer / Refer / Decline — with reasons tied to the computed signals, sized to a requested amount/tenure.

• Built: src/domain/decision.py (Layers 3–4, per-product presets, SME round-5 sign-off); in-app decision panel + per-tenant policy editor; override & approvals workflow with delegated authority (L1/L2/L3), claim/resolve/escalate, append-only audit, un-overridable hard-blocks (src/domain/authority.py). The engine recommends, a human decides.
• Calibration (🟡): the backtest harness is built (scripts/backtest.py); pending lenders’ real decided-case data, after which the SME asked to freeze policy until validated.
• Positioning-safe: the lender owns the policy and a human resolves every case, so Obsrv stays “decision support, not the credit decision” — the regulatory line we deliberately hold.
• Phase 3 (not built): business-lending turnover/DSCR/seasonality weighting over FOIR.
• Depends on: Borrower Case.

5. Decision packet + audit trail · 🟡 · Workflow

An immutable, filed artifact: the consolidated report + who decided what, against which policy version, when. Lenders file these for audits.

• Shipped so far: the append-only decision trail (claim → override → resolve, reason-coded) and a CSV export of the approvals queue (the ask, financials, engine call, resolution) for the audit file / LOS import — the lightweight first cut.
• Still to build: the per-case decision-packet PDF (consolidated report + decision record
  • policy version, as one filed document).
• Why: elevates the audit log + export into a first-class, human-readable deliverable.
• Depends on: Borrower Case (+ the Policy/decision layer, now built, for the decision record).

Below the line (later / post-PMF)

The unifying pitch

Obsrv is the verifiable underwriting workspace for a borrower — collect their documents, prove they’re real, consolidate them into one reconciled financial picture, decide against your own policy, and file an auditable packet. Every step is deterministic and verifiable — a consolidation a lender can verify end to end.

Recommended sequencing

1. Borrower Case (#1) — the spine. Build it first; it fixes pricing and unlocks the rest.
2. Tamper detection (#2) — slot in as the Case’s “Verify” step. Closes the loudest gap, most on-brand.
3. Intake link (#3) — fill the Case.
4. Policy / auto-decision (#4) — act on the Case.
5. Decision packet (#5) — file the result.

Honest caveat — commercial wrapper comes first

features.md’s scoreboard puts the path to first revenue in unglamorous plumbing: wiring a real payment gateway (purchase infra is built — needs keys), DPDP consent text, VPC hardening before real PII. Do not build the Borrower Case in a state where we cannot yet take money or legally hold a real applicant’s data. The strategic answer is the Case; the sequencing reality is: land one paying lender on the single-statement product, learn, then build the Case as the thing that expands the account.

Open decisions this roadmap forces

• Per-borrower pricing bundle Decided (2026-06-23): pure-consumption credit packs, not a bundle (₹500/₹1,000/₹2,000, bonus, 12-mo expiry, non-refundable). Purchase infra built (factory + mock); remaining is wiring a real gateway’s keys. See pricing.md.
• Tamper detection: build vs. partner — deterministic checks we can own; ML-forgery models may be buy/partner.
• How opinionated the policy layer is — templates vs. free-form rules vs. a small DSL.