RUKMAYALet’s Talk

Building BANKTRUST: Trust-First Bank Statement Exports for Accounting Firms

Dec 12, 2025

In accounting, speed is useful — but trust is non-negotiable.
If the numbers don’t reconcile, nothing else matters.

BANKTRUST started from a simple but uncomfortable question:

“Why are accountants still retyping bank statements in 2025?”

Not because better tools don’t exist —
but because most automation tools ask users to trust results they can’t verify.

BANKTRUST is our answer to that gap.

This is the story of how we’re building a trust-first bank-statement-to-ledger pipeline for bookkeeping and accounting firms handling multiple clients every month.

The Problem: Automation Without Confidence

For many accounting teams, monthly bank statements are still painful:

  • PDFs arrive in different formats, layouts, and quality
  • OCR tools extract data, but:
    • totals don’t always match
    • balances drift
    • edge cases silently fail
  • The result is a dangerous tradeoff:
    • Trust the machine blindly
    • or retype everything by hand

Neither option scales.

On the firm side, this shows up as:

  • Hours lost reconciling “almost right” exports
  • Senior staff double-checking junior work
  • CSV files that look clean but can’t be trusted without manual review

The core issue isn’t parsing.
It’s confidence.

The Core Idea: Trust Must Be Visible, Not Assumed

Early on, we made one foundational decision:

BANKTRUST would never hide uncertainty.

Instead of pretending every parse is perfect, we designed the system to:

  • Show what it’s confident about
  • Flag what needs attention
  • Prove that totals reconcile — or clearly show when they don’t

In other words:

Trust isn’t a claim. It’s a measurable output.

That idea shaped everything that followed.

Building the Backbone: Statements, Transactions, and Trust Metrics

We started with the boring, essential questions:

  • Can we always reconcile opening and closing balances?
  • Can we prove where every number came from?
  • Can an accountant review results without leaving the tool?

1. Statement-Centric Ingestion

In BANKTRUST, everything starts with a statement, not raw rows.

Each uploaded PDF produces:

  • A statement record with:
    • start date
    • end date
    • currency
    • opening & closing balances
  • A full transaction list
  • A calculated variance (amount + percent)
  • A confidence score that reflects parse quality

If the math doesn’t close, the system doesn’t pretend it does.

2. Trust Signals, Not Black Boxes

Instead of “success / failure,” each statement surfaces:

  • Confidence percentage (e.g. 98.5%)
  • Variance indicators
  • Anomaly flags at transaction level:
    • balance gaps
    • suspect parses
    • outlier amounts

This lets accountants answer the real question:

“Can I rely on this export — and if not, where should I look?”

The API: Built for Firms Who Automate Everything

BANKTRUST isn’t just a UI tool.
It’s designed to slot into existing workflows.

So we exposed a clean, minimal API:

  • POST /api/v1/statements
  • Auth via per-firm X-API-Key
  • Multipart upload:
    • PDF file
    • client_id

The response mirrors the UI:

  • statement summary
  • confidence + variance
  • full transaction list with anomaly metadata

No “magic success.”
Just structured data firms can build around.

API documentation is public at:

👉 https://banktrustapp.com/docs/api

Shipping the Product Surface: Landing, Docs, and Early Access

Once the core system was working, we focused on making BANKTRUST presentable and honest.

What we shipped:

  • Public landing page
    • Clear positioning: ledger-ready exports you can trust
    • No pricing pressure — early access only
  • Early-access waitlist
    • Email-only, manually curated cohort
  • API reference docs
    • Concrete examples, not marketing fluff
  • Product walkthrough video
    • Short, silent screen demo showing:
      • upload → trust view → export

All deployed on a lean stack:

  • Next.js (App Router) on Vercel
  • Supabase for auth, data, and storage
  • Minimal dependencies, maximum clarity

What We Learned (So Far)

A few lessons reinforced themselves quickly:

  1. Accountants don’t want “smart” — they want explainable
    Confidence beats cleverness every time.

  2. Variance is not an error — it’s information
    Surfacing mismatch early builds trust faster than hiding it.

  3. Good UI doesn’t replace good math
    The product only works because reconciliation is first-class.

  4. Early access works best when it’s human
    We deliberately chose manual onboarding to learn from real firms.

What’s Next for BANKTRUST

BANKTRUST is live, but early.

Next steps include:

  • Parser upgrades
    • More layouts
    • Better edge-case handling
  • Google Sheets export
    • OAuth-based, one-click delivery
  • API key management UI
    • Create, rotate, revoke keys in-app
  • Clear pricing tiers
    • Once usage patterns are real, not hypothetical

All guided by the same rule:

If trust drops, the feature isn’t done.

Why This Matters to RUKMAYA

BANKTRUST reflects how we like to build at RUKMAYA:

  • Start from real operational pain
  • Design around human verification, not blind automation
  • Keep the stack lean so the workflow stays legible

If you’re building in fintech, accounting, or any system where numbers matter, the lesson is simple:

Don’t just automate the output.
Design for the moment someone asks, “Can I trust this?”

— The RUKMAYA Team

Share this post

Share on LinkedInShare on X