openaccountants
All posts

From Transaction to Filed Return: The Three-Layer Model for Embedded Tax

Michael Cutajar|15 June 2026|4 min read
platformsarchitectureembedded-taxhow-it-works

When platforms ask "what does it take to add tax?", the honest answer is that "tax" is three different jobs wearing one word. Conflate them and you build either a toy (a calculator that nobody trusts to file) or a bottleneck (a human in front of every question). Separate them cleanly and you get a layer that's instant where it can be and accountable where it must be.

Here's the model we build around.

Layer 1 — In-app intelligence (what the user sees)

This is the surface. It lives inside your product, speaks your product's language, and answers the questions your users already have but currently take elsewhere:

  • "How much of this payout is actually mine?"
  • "Am I setting aside enough?"
  • "What's my estimated liability so far this year?"
  • "When's my next deadline, and am I ready for it?"

The defining feature of Layer 1 is that it's year-round. A running estimate that updates as money moves. A set-aside pot that grows with each payment. A nudge before a deadline. This is the layer that turns tax from a January panic into a reason to open the app in March, July, and October. It's also the cheapest layer to get wrong — because it's only as trustworthy as what sits underneath it.

Layer 2 — The tax engine (what does the reasoning)

Underneath the UI is the part that actually computes. This is not a static calculator with hard-coded rates that rot every April. It's an engine that takes this user's data — income, categories, dates, jurisdiction, employment status, prior balances — and reasons over it against current, jurisdiction-accurate rules, showing its working.

Two things make or break this layer:

  • Coverage and currency. Rates, thresholds, allowances, and deadlines for every country and US state your users live in, kept current as they change. This is the part platforms can't justify building in-house — it means a standing tax-research function for every jurisdiction, forever.
  • Transparency. Every number traces back to a rule, and every rule traces back to a source. "Trust me" doesn't survive contact with a tax authority; "here's the rule and here's where it comes from" does.

This is the layer OpenAccountants exists to be. The rules are open and sourced; the engine is the thing you integrate instead of hiring a global tax department.

Layer 3 — The warranted accountant (who stands behind it)

The engine can answer most questions instantly because the human work is already baked into the rules — a credentialed accountant verified them once, so they're trustworthy at scale. But the moment a user files something or relies on a number with consequences, you need the other kind of human work: a named, licensed accountant who reviews the specific output and stands behind it.

This is the layer platforms are tempted to skip, and it's the one that makes the whole thing safe to ship. "An app told me" is not a defence to a tax authority. A real accountant's review is. We went deep on why in what a warranted accountant actually means — the short version is that the credentialed human is the difference between a tax layer and a liability.

The handoffs are the product

The model only works because the layers pass to each other cleanly:

  1. A transaction lands in your platform → Layer 1 surfaces what it means.
  2. The user asks a real question → Layer 2 reasons over their data and answers, instantly, with sources.
  3. The user is ready to file → Layer 3 routes to a credentialed accountant who reviews and warrants it, and the status flows back into your app (reviewing → filed).

Each layer does the job it's actually good at: the UI is fast and native, the engine is accurate and current, the human is accountable. No layer pretends to be another.

What you actually build

Almost none of it. Layer 1 is your product surface — you own that, and you should. Layers 2 and 3 are what OpenAccountants provides as a single integration: the verified rules, the engine that reasons over them, and the network of accountants who stand behind what gets filed. You wire it into the data you already hold, and your users get an answer where they used to get a shrug.

Want to see the three layers wired into a real stack? Read the platform overview or book a call.