Design your own reconciliation flow
Last reviewed·ReconPe Editorial
Flow Studio is ReconPe’s visual canvas for the reconciliations that don’t fit a standard two-file template. Drag nineteen typed building blocks onto a canvas — or let AI design the flow for you, grounded in your own SOPs with a verbatim citation on every step. Describe rules in plain English and AI compiles them into deterministic plans, validated against your actual columns. Run it daily and the flow remembers: every break is an identity followed across runs, and the ones that fix themselves close automatically with an audit receipt. Breaks land in the exception queue with approval chains, and finished flows become templates your team starts from.
Drag typed blocks from the dock onto the canvas — required ports auto-wire to the nearest upstream node.
Why a canvas, not another template
Real reconciliations aren't two clean files
A payout nets orders, fee rebates, ads charges, and tax recoveries into one bank credit. Marketplace deductions arrive on later settlements. One invoice pays out across two cycles. A fixed two-file template can't express that shape — a flow can.
Every business has one recon nobody's tool covers
Franchise royalties against POS data. A logistics partner's COD sheet against your OMS. An internal transfer register against two banks. Flow Studio exists for exactly these — you assemble the reconciliation instead of waiting for us to ship an adapter.
Excel gymnastics can't be audited
The pivot-table-and-VLOOKUP version of a custom recon lives in one person's head and breaks when they're on leave. A flow is explicit: every step is a named node, every run is recorded, and every break carries an approval trail.
Nineteen building blocks, typed and wired
Every node has typed input and output ports — the canvas validates port contracts, catches cycles, and auto-wires required inputs to the nearest upstream node when you drop a block.
Inputs · 3
- File — An uploaded CSV, Excel, JSON, PDF, or image dataset
- Multi-file merge — Several files unified into one dataset, schemas aligned by AI
- Connector — REST, JDBC, and S3 inputs — coming soon; files and multi-file merges are live today
Transforms · 7
- Filter — Keep only rows matching a condition — plain English supported
- Aggregate — Group rows and roll up: sum, count, avg, min, max, concat
- Derive column — Add computed columns and time buckets (15-min to monthly) — plain English supported
- Deduplicate — Keep first or last row per key set
- Union — Stack column-aligned datasets into one
- Lookup / enrich — Left-join reference columns onto the main dataset by key
- Router — Route rows to true/false branches — plain English supported
Recon · 6
- Field Mapping — Map source columns to target columns, AI-suggested and editable
- Rule Creation — Keys, tolerances, and filters — AI-suggested and editable
- Match — Reconcile two datasets with the ACRE engine; breaks become exceptions
- Netting — Verify two sides net to zero — offset and hedge matching
- Join — Key-join two datasets; left-only rows surface separately
- AI Bridge — Discovers the hidden fee or rate tying two aggregated sides — you approve it
Outputs · 3
- Results — Match rate, matched and unmatched counts, drill-down
- Exceptions — Persist breaks into the exception queue and approval chain
- Export — Export any dataset as a CSV or report
What a flow looks like in practice
Four shapes finance teams actually need — every one assembled from the same building blocks above. Pick a tab and watch it wire itself.
Twelve invoices paid with one NEFT. Aggregate rolls vendor bills into an expected payout; Match ties each group to its bank credit; anything left over lands in the exception queue as an unpaid bill.
Your files + your SOPs in. A running flow out.
Upload your organisation’s context once — settlement policies, desk SOPs, dataset notes. Then pick your files, say what you want in one plain-English sentence, and the AI designs the whole flow.
Grounded, with receipts
Every step the AI can justify carries a verbatim quote from your own documents — “Hedge quantities must tie exactly” — with the source named. Quotes it can’t prove are stripped automatically and the step’s confidence drops. No invisible authority.
Validated before it exists
The draft passes the same deterministic gate as everything else: only real building blocks, only your columns, only the files you picked. Anything the AI got wrong is sent back once for repair, and whatever remains is flagged on the canvas — the draft is yours to review, never silently applied.
First sight: live numbers
A runnable draft doesn’t wait — it opens on the canvas and runs once, so the first thing you see is your reconciliation with real match rates and real breaks. Review each AI-placed step by its violet chip, edit anything, run again.
Flows that remember. Breaks that heal themselves.
Run a flow daily and every break becomes an identity with a life story — not a fresh exception dump each morning.
The storyline
Each break’s lifeline runs across your recent runs: born, carried forward, healed, or resolved by a person. After each run, one line tells you what changed — “1 healed itself · 2 carried · 1 new” — and the canvas itself shows which step is carrying old breaks.
Self-healing, with an audit note
When the late settlement finally lands and matches, the old break closes itself — with a receipt showing the day it opened, the run whose data healed it, and the audit note that was written. Healing needs positive proof: a matched row, never mere absence from a file.
Honest expectations
Once a flow has enough healed history, open breaks show how long similar breaks usually took to heal — and get flagged as overdue when they blow past it. No history, no guess: the storyline stays silent rather than invent a prediction.
AI at design time. Determinism at run time.
The same discipline as everywhere in ReconPe: AI drafts, suggests, and discovers while you design — but what runs is a deterministic graph you approved, and what it finds becomes an auditable exception trail.
Plain English in, determinism out
Type “only delivered orders over ₹1,000” on a Filter, Router, or Derive node. AI compiles it into a rule plan; a compiler gate then checks every referenced column against your file's real schema and rejects anything off-schema before it can run. You see the compiled rule and can edit it field by field. If the AI provider is unavailable, the editors still work — the plain-English bar is a shortcut, not a dependency.
AI Bridge: it finds the fee you can't see
Two aggregated sides that never tie out usually differ by a hidden relationship — a commission, a rate, a fixed fee. Point the AI Bridge node at both sides and it discovers the relationship, names it, and shows its confidence and reasoning. You approve it; only then does the deterministic tie-out use it.
Preview before you trust
Every transform and recon node has a 'Preview output' button that sample-runs the upstream graph and shows the actual headers and sample rows at that point. You verify each step on real data at design time — not after a failed run.
AI proposes. Your admin disposes.
Save a flow as a template and your team can start from it. If any part of the template was AI-authored, it doesn't publish silently: a frozen copy waits in an admin approval inbox with the AI's summary attached, and an admin approves or rejects it with a recorded reason. AI never becomes shared configuration without a human signature.
Breaks land where work happens
A Match node's breaks aren't a dead grid in a designer — they persist as real exceptions on a real reconciliation, scoped to that run, with the full assignment, approval, and resolution chain. One click on the run panel opens them in the Exceptions workspace.
An editor that behaves like one
Undo and redo (Ctrl+Z / Ctrl+Shift+Z), autosave every edit, a run-history picker that overlays any past run's node statuses onto the canvas, PNG export of the graph, and a readiness check that tells you exactly what's unbound before you run. On mobile, flows open read-only for review on the go.
From blank canvas to worked breaks
- 1
Start from a template, a blank canvas — or let AI design it
Pick a team template to open an editable copy, click 'Start a 2-file reconciliation' to seed the canonical chain in one click, or use Design with AI: pick your files, describe the goal in plain English, and the AI drafts the whole flow — grounded in your organisation's own SOPs and notes, with a verbatim citation on every step it can justify.
- 2
Drop your inputs
Add File nodes for uploaded CSV/Excel/JSON datasets, or a Multi-file merge node that unifies several files into one dataset with AI-aligned schemas.
- 3
Shape the data with transforms
Filter, aggregate, derive columns, deduplicate, union, lookup-enrich, or route rows into branches. On Filter, Router, and Derive you can describe the rule in plain English — AI compiles it into a deterministic plan validated against your actual columns, and you edit the result.
- 4
Preview any node before you run
Click 'Preview output' on a node to sample-run the upstream graph and see real headers plus sample rows at that exact point — before anything executes for real.
- 5
Run the flow
The readiness check confirms every file is bound and every Match node is configured, then nodes execute in dependency order with live statuses on the canvas.
- 6
Work the breaks, save the flow as a template
Match breaks persist into ReconPe's exception queue with assignment and approval chains — one click opens them. Save the finished flow as a template for your team; AI-authored parts go to an admin approval inbox before the template is shared.
- 7
Run it again tomorrow — the flow remembers
Every break is an identity followed across runs. Re-run on tomorrow's files and the storyline shows what's new, what's still open, and what healed itself when the late data arrived — closed automatically with an audit note. Generate a PDF report that narrates the run step by step, straight from the flow you designed.
Flow Studio — frequently asked questions
What is Flow Studio?+
Flow Studio is ReconPe's visual canvas for designing custom reconciliations. You drag typed building blocks — file inputs, filters, aggregations, lookups, joins, netting, and the ACRE match engine — onto a canvas and wire them into a flow. AI helps at design time (plain-English rules, mapping suggestions, bridge discovery); execution is deterministic and every break lands in ReconPe's exception queue.
Do I need to write code to build a flow?+
No. Flows are assembled visually, and on Filter, Router, and Derive nodes you can describe the rule in plain English — AI compiles your words into a deterministic plan that is validated against your file's actual columns, and you can edit the compiled result field by field. There is no scripting language to learn.
What building blocks are available?+
Nineteen node types across four groups: three inputs (File, Multi-file merge, Connector), seven transforms (Filter, Aggregate, Derive column, Deduplicate, Union, Lookup/enrich, Router), six recon nodes (Field Mapping, Rule Creation, Match, Netting, Join, AI Bridge), and three outputs (Results, Exceptions, Export). Every node has typed input and output ports, and the graph is validated for cycles and port contracts as you build.
What is the AI Bridge node?+
AI Bridge ties out two aggregated sides that differ by a hidden relationship — a commission rate, a fixed fee, a percentage. The engine discovers the relationship, names it, and reports its confidence and reasoning. You approve the relationship before it's used; the tie-out itself then runs deterministically with the approved parameter.
What happens to breaks a flow finds?+
Breaks from a Match node persist as real exceptions on a reconciliation owned by that node, scoped to the run. They enter the same exception workspace as every other ReconPe reconciliation — assignment to teammates, approval chains, resolution tracking — and the flow's run panel deep-links straight to them.
Can my team reuse a flow I built?+
Yes. Save any flow as a template and teammates start from it with one click — each start creates a fresh editable copy bound to their own files. Templates that contain AI-authored configuration go through an admin approval inbox before they're shared with the organisation, so AI output never becomes team-wide configuration without human review.
Can AI design the whole flow for me?+
Yes. Design with AI takes your chosen files, your plain-English goal, and your organisation's own context documents — SOPs, settlement policies, dataset notes you upload once — and drafts the complete flow. Every step the AI can justify carries a verbatim quote from your documents; quotes it cannot prove are stripped automatically, and steps designed only from the files' shape say so honestly. The draft opens on the canvas, runs once so your first sight is live numbers, and stays fully editable — nothing is final until you say so.
What happens when I run the same flow every day?+
The flow remembers. Every break is an identity followed across runs — the storyline shows each one being born, carried forward, and either resolved by a person or healed by later data. When yesterday's missing settlement arrives and matches today, the break closes itself with an audit note and a receipt showing exactly which run's data healed it. Once a flow has enough healed history, open breaks also show how long similar breaks usually take to heal — and get flagged when they're overdue.
Can I get a report of a flow run?+
Yes — one click on the run panel generates a PDF that follows your flow exactly as you designed it: every step narrated with the run's real numbers, what changed since the previous run, and each break's life so far including self-heal receipts. Because the report is built from your own flow graph, it reads as your process, not a generic template.
Is flow execution deterministic?+
Yes. AI participates only at design time — suggesting mappings, compiling plain-English rules, discovering bridge relationships — and everything it produces is reviewable and editable before it runs. At runtime the flow executes as a deterministic graph: nodes run in dependency order, matching runs on the ACRE engine, and re-running the same flow on the same inputs produces the same result.
Your weirdest reconciliation is a flow away
Free tier, no credit card. Start from a blank canvas or a one-click two-file reconciliation and build from there.
Start building