Custom reconciliation software development

Reconciliation engines that match what they can prove, queue what they can't, and record who decided the rest.

Start a project

Reconciliation tends to fail in the same way everywhere. A spreadsheet or a matching script handles most rows, and the rest end up in a tab called “check later”. Nobody is sure which matches were automatic and which were guesses. When the auditor asks why two numbers agree, the honest answer is that someone made them agree.

Custom reconciliation software is worth building when that gap costs you hours every close, or when you can’t explain a match after the fact.

What we build

  • Bank-to-ledger reconciliation: statement lines checked against their own printed balances, then matched to ledger entries.
  • Transfer and intercompany matching: money that leaves one account and arrives in another of the same group, so it isn’t booked as income or expense.
  • Payout reconciliation: processor or marketplace settlements tied to the orders, fees and bank deposits behind them.
  • Tie-out checks on third-party files: schedules from issuers, lenders or partners whose rows have to add up before you import them.

How we build it

We run these engines in production in our own products: Lekhavo, a bookkeeping platform for accounting practices, and NCD, which reconciles bond interest schedules. The details below come from that code.

Exact money, always

Amounts are stored and added as integers: paise in Lekhavo, BigInt micro-units in NCD, where the source files carry sub-paise precision. A floating-point round trip can shift a value by a paisa. On a tie-out check, that turns a correct row into an exception, or a wrong one into a match.

Check the source before matching anything

Every statement is checked against itself first: opening balance plus every transaction must equal the closing balance, to within ₹1. An import that misses is held before any transaction is committed and waits for a reparse or a decision. It never flows into the books with a gap nobody mentioned. Our bank statement parser runs these checks against the totals printed on the statement.

Matching rules you can read

Lekhavo’s transfer matcher works in two passes over transactions of equal amount:

  1. Shared reference. A debit and a credit in different accounts that carry the same bank reference number, posted no more than two days apart, are matched. The pattern that picks out references skips bank branch codes, so a shared branch code doesn’t count as a shared reference.
  2. Amount and date. Among the rest, the matcher takes every same-day pair before any one-day pair, and every one-day pair before any two-day pair. Without that order, an early debit could take the credit a later debit needed for its exact-date match.

Each match records its method (reference, amount and date, manual, or cash book) and starts as pending until someone approves or rejects it. Matching never pairs two lines in the same account.

An exceptions queue, not a pile

Everything a person has to decide goes into one worklist, sorted by kind and age: held statement imports, balance mismatches, transfer matches waiting for approval, transactions to review, and documents still owed by a client. Age buckets (this week, this month, older) show what is slipping before a deadline does.

Refusals as values

When a row fails a check, our code returns a result that lists which rows block the step and why, with the file, sheet and row number a person can open. It doesn’t throw an error that only says “failed”. In NCD, a failing row is stored and flagged, not dropped. Dropping it would understate a client’s position by an amount the software never mentions. The NCD case study covers this in detail.

Closed periods stay closed

Once a financial year is locked, a change to a transfer match touching that year is refused with an explicit “year locked” response, not applied quietly. Exports enforce their own rules: every voucher sent to the accounting system must balance to zero paise, or the export stops.

An audit trail that answers “who decided this?”

Each data change records the actor (staff, client or system), the record, the operation, the fields changed and the request it came from. Audit metadata never includes client financial data such as payees or amounts, so the log can be shared with the people who need it.

How the work is run

Tembrant builds with an AI software factory: many agents work in parallel, held to fixed gates. Every change starts from a written spec. Tests are written first, and they run against fixtures measured from real source files, not invented samples. Each change gets independent reviews, and a person signs off before it ships. For reconciliation, that means every matching rule and tolerance is written down and tested before any code uses it.

What you get

  • A matching engine with documented rules and tolerances, and tests built from your real file formats
  • An exceptions queue your team can work from, with an owner and an age on every item
  • An audit trail of every match, override and lock
  • Exports into the ledger or ERP you already run
  • Source code, a spec and runbooks your own team can maintain

If month-end still depends on a “check later” tab, tell us what you reconcile and where the files come from.

Questions

Can a reconciliation engine match everything automatically?
No, and one that claims to will hide errors. We match what the data proves, such as a shared bank reference or an exact amount within a short date window, and send the rest to a queue where a person decides. Each match records how it was made, so a reviewer can trust the automatic ones and check the rest.
How do you handle rounding differences?
Money is held as exact integers (paise or cents, or micro-units where the source carries more precision), never as floating point. A tolerance is a named rule set from the source's real rounding behavior, for example ₹1.50 where an issuer rounds interest and tax on each line separately, not a fudge added later.
Do you replace our accounting system?
No. The engine sits between your source files and your books. It checks and matches transactions, then hands balanced entries to the ledger you already use, through that system's import format or API.
Have you built payout reconciliation for payment processors?
Our production engines reconcile Indian bank statements, ledgers and bond interest schedules. Processor and marketplace payouts have the same shape: a settlement file, the orders and fees behind it, and a bank deposit that should equal their net. We'd build it with the same matching, exception and audit design, scoped to your processors' file formats.

Have financial data that has to tie out?

Tell us what you want to build. We reply with questions, a plan and an estimate.

Start a project