Skip to content
Every figure traces to a ledger row, or the deliverable does not render

Reconciliation · Returns · Audit

A working-papers system of record for
chartered accountants

Legosphere Finance computes every figure in exact decimals, cross-foots every table before a word is drafted, and refuses to render a deliverable whose numbers do not tie. Tax rates are effective-dated data keyed by assessment year, so a computation is never quietly performed with last year’s slabs.

  • The model writes no figures
  • Nothing renders if it does not tie
  • Rates are data, not code
  • A draft until a partner signs

Three surfaces

An engine, a workspace, and the statutory work beside them

One record underneath all three: it holds the engagement and its ledgers, the engine computes against it without being able to write prose, and the console is where a person applies judgement and signs.

The engine

The computation engine

Deterministic arithmetic, with the drafting kept outside it. Reconciliation, tax computation and depreciation are computed in Python against exact decimals, and an arithmetic gate cross-foots the result before anything downstream is allowed to run. Nothing in this path is a language model, which is what makes the output defensible.

  • Exact decimals end to end — a 5,000-row bank reconciliation ties to exactly zero, not to a residual
  • Slabs, surcharge bands, marginal relief and depreciation rates keyed by assessment year
  • Every table cross-footed, and a job whose figures do not tie ends naming the account and the amount
  • A computation that cannot be performed is refused, never returned with the figures missing
  • Every computation records the checksum of the rate set that produced it

Members who sign · reviewers · anyone who has had a figure questioned

The computation engine
The workspace

The working papers console

Where the judgement is applied and the signature happens. Engagements, imports with every rejected row on screen, the side-by-side reconciliation grid, working papers with tickmarks, review notes against a section, and a sign-off gate that will not open early.

  • The reconciliation grid where the difference walks to zero as a clerk clears items
  • Rejected import rows listed exactly as the file wrote them, with the reason each was refused
  • Click any figure in a deliverable and see the computation line and the ledger row beneath it
  • Review notes raised against a section, assigned, answered and closed before anything is signed
  • Items outstanding at the end of a period carry forward keeping the period they were first raised in

Members · managers · articled assistants · a peer reviewer

The working papers console
The statutory half

Returns and statutory work

The work that sits beside the audit and has its own deadlines. GST reconciliation against the portal statement with input credit eligibility applied, TDS against Form 26AS section by section, Form 3CD, and a calendar of what is actually due rather than a checklist someone maps onto a diary.

  • Purchase register against the portal statement, invoice by invoice, with supplier-wise mismatch ageing
  • Input credit eligibility and reversal applied with the rule cited on the line it disallowed
  • TDS against Form 26AS with section rates and lower-deduction certificates recognised
  • Advance tax, Form 3CD, the return, GST and TDS on one calendar with overdue and at-risk flagged
  • A deliverable exports as a document, a spreadsheet with the working intact, or structured data

Compliance practitioners · in-house finance teams · anyone with a due date

Returns and statutory work

The specification

What it is, and what it is not

The questions that actually decide this purchase are specification questions. They are answered here rather than on a second call.

What this is

A system of record for the working papers behind a professional deliverable: firms, clients, engagements, imported ledgers, reconciliations, computations and the documents produced from them — with a deterministic computation engine over the top and a drafting layer that is only allowed to write prose. It is built to the way Indian practice actually works, which is what fixes the rules the rest of this site describes.

What this is not

Not a tax advisor, not an accounting package, and not an opinion. It does not decide a client’s tax position, it does not choose a treatment, and it does not form an audit opinion — it produces the working, ties it, shows where every figure came from, and leaves the judgement and the signature with the member whose name goes on the document.

DomainReconciliation, statutory compliance and audit deliverables — the working papers behind them, not the client’s books themselves
ArithmeticExact decimals end to end, in the database and in the browser. No floating-point number touches a rupee figure at any point
RatesSlabs, surcharge bands and depreciation rates are effective-dated rows keyed by assessment year, from reviewed and checksummed sources
The gateEvery table is cross-footed before anything is drafted. A deliverable that does not tie is refused, and the refusal names the account and the amount
ProvenanceEvery rendered figure comes from a computation line; every line carries the ledger row it was computed from
IngestionParsed plus rejected plus duplicate must equal the rows submitted. Every rejected row is kept exactly as the file wrote it, with its reason
TenancyThe firm is the tenant, enforced where the query is built. A read across firms answers as though the record does not exist
ReconciliationA cleared item carries a narration in the schema, and an item outstanding at period end carries forward keeping the period it was first raised in
Sign-offA partner, with no review note left open. The person who proposed an adjustment cannot be the person who approves it
IntegrationThe console is one client of the API. Completion callbacks are signed, so a finance system can take a reconciliation into its own records

Why it is built this way

A wrong figure in a signed document is not a bug report.

It is a disciplinary matter for the member who signed and a notice for the client. That is the whole difference between this domain and ordinary business software, and it is why almost every rule on this site is written as a refusal rather than as a capability. Nobody is harmed by software that declines to produce a document. People are harmed by software that produces a confident one.

The expensive failures here are quiet. A trial balance that is out by a small amount looks exactly like one that balances, until somebody cross-foots it by hand. A tax computation performed with last year’s surcharge bands produces a number in the right shape and the wrong amount. A figure a drafting model wrote into a paragraph is indistinguishable, on the page, from one the arithmetic produced — until a reviewer asks which ledger row it came from, and the answer is that it did not come from one.

So the architecture is aimed at those specifically. Figures may only reach a rendered document from a computation line, and a number appearing in prose without one blocks the render rather than shipping. Every table is cross-footed before anything is drafted, and a set of books that does not tie ends the job naming the account and the amount rather than producing a deliverable somebody would sign. An assessment year with no reviewed rate set is refused outright instead of being computed with the previous year’s numbers, which is the failure nobody notices until an assessment.

None of that makes the accounts right. It makes them reviewable, which is the only property software can actually give a set of working papers. The judgement stays with the person whose membership number is on the last page.

How it works

What happens to an engagement

Five stages between a ledger arriving and a signed deliverable going out, each with a rule attached. The rules are the interesting part — most exist because of a way work like this fails quietly.

  1. 01

    Take the engagement

    A firm, a client, an engagement and an assessment year, none of them defaulted. The assessment year then decides which rate set applies, so a computation cannot later be performed against rates nobody reviewed for that year.

  2. 02

    Ingest, and reject loudly

    Ledgers, bank statements, portal downloads and register exports are parsed row by row. An unreadable row is an error naming the row and the reason, never an empty result — parsed plus rejected plus duplicate has to equal what you gave it, and the rejected list is a screen rather than a log.

  3. 03

    Reconcile and compute

    Matching runs against the row fingerprint, so an item outstanding in March reappears in April pointing at its predecessor. Tax, depreciation and the statutory schedules are computed in exact decimals against the rate set for the year.

  4. 04

    Cross-foot, or stop

    Every table is cross-footed before anything is drafted. If it does not tie, the job ends naming the account and the amount, and the three checks a member runs by hand are run first — an account carrying the difference, one carrying half of it, and the divisible-by-nine test for a transposition.

  5. 05

    Draft, review, sign

    What renders carries only figures from computation lines. Review notes are raised against sections and have to be closed, an adjustment cannot be approved by whoever proposed it, and it is watermarked a draft until a partner signs.

The engine, stage by stage

What it has to satisfy

Twelve rules that constrain the software

Each one is a constraint rather than a capability, and each is written so a customer can hold the software to it. Most of them describe something it refuses to do.

  • The model never produces a number

    A figure reaches a rendered document from a computation line or it does not appear. A number a drafting model wrote into a sentence is a blocking error rather than a paragraph to proofread, which is the only version of this rule that survives a busy March.

  • Nothing renders if it does not tie

    The arithmetic gate cross-foots every table and has no bypass — not a parameter, not a setting, not an exemption for one kind of job. A deliverable that does not add up is worse than no deliverable, because somebody will sign it.

  • Rates are data, not code

    Slabs, surcharge bands and depreciation rates are effective-dated rows keyed by assessment year, from reviewed and checksummed sources. An unseeded year is refused rather than computed with last year’s numbers.

Read all twelve

Questions

What people ask first

Mostly one question in several forms: does the software decide anything? It does not, and these are the mechanisms that keep it that way.

No, and it is built so that it cannot quietly start to. It computes what the figures come to under the rate set for the assessment year, under the regime and the treatment somebody selected. Choosing the treatment, choosing the regime, and taking responsibility for the position are the member’s, and the deliverable is a watermarked draft until a partner signs it. Where a question is a matter of judgement rather than arithmetic, the software takes it as an input and says so.

Point it at a reconciliation that took somebody a week

The useful conversation starts from a real engagement rather than from a deck: which reconciliation eats the most time, what a reviewer sent back, and what the practice does in the last week of the filing season. Tell us that and we will tell you plainly whether this fits.

Get in touch

Talk to the people building it

No chatbot and no ticket queue. Tell us what your practice actually looks like — how many members sign, how many prepare, which of audit, tax and compliance you do most of — and someone who works on the software will reply.

info@legosphere.com

Please keep client names, PANs, GSTINs, account numbers and ledger extracts out of this box — it is an ordinary enquiry form, not a channel for a live engagement.