Omnilogic Labs

FINANCE CONSULTING // ADVISE

FP&A Automation: the argument is the artifact.

A financial-planning-and-analysis consultancy wanted to automate finance work with AI — without the all-or-nothing rewrite that sinks most such efforts. We didn't hand them a deck. We built a live, executable model of their own workflows where every step is a swappable Human / AI / Program node. Flip a node, run the workflow, and watch it either flow through to completion or block on a step where judgment still lives.

The deliverable persuades by letting the client run the experiment themselves: you can see exactly which slot to automate first, and which one to leave alone. Tune to the right signal; know which knob to turn.

FIG. WORKFLOW_AS_GRAPH
REF: WORK-08A finance workflow as a graph: each node a swappable human, AI, or program implementation

01 // The problem

The all-or-nothing trap.

SPEC_ID: FPA-PROBLEM // FAILURE-MODE: BLACK-BOX REWRITE

The consultancy wanted AI in their finance workflows but kept hitting the trap that sinks most such efforts. Either you keep doing everything by hand, or you attempt to replace an entire process with a black box — and discover too late which steps genuinely needed a human.

They needed a way to think about automation that was incremental, honest about where AI helps and where it doesn't, and grounded in their actual workflows rather than a vendor's promise. Not a roadmap on a slide. A way to reason, step by step, about their own process.

  • Manual-everything is slow and doesn't scale with the work.
  • A full black-box rewrite hides where human judgment was load-bearing.
  • Generic vendor automation isn't grounded in the team's real workflows.
  • A static deck can't show consequence — only a running model can.

02 // The approach

Encode the workflow first. Then automate one slot at a time.

The thesis is simple to state: put a human in every slot, then automate one swappable step at a time, keep humans where judgment lives, and let the workflow show you the order. The trick was to make it operable — not a document, an engine the client could run.

NODE: HUMAN
person

Human

Judgment, sign-off, exception handling. The default implementation in every slot — and where it stays whenever the workflow proves a human is load-bearing.

NODE: AI
smart_toy

AI

A model drafts, classifies, or summarizes the step. Flip a node to AI, run the workflow, and see whether the rest of the graph still flows or needs a human gate behind it.

NODE: PROGRAM
function

Program

Deterministic code for the steps that are rules, not judgment — the cheapest, most reliable implementation when the logic is fixed and well understood.

FIG. HUMAN / AUTOMATION BOUNDARY
REF: METHOD-01Process boundary: automated steps to the left, human judgment to the right, with a handoff between them

03 // What we built

An interactive thesis, not a document.

Each finance workflow is modeled as a graph. Every node carries a swappable implementation — Human, AI, or Program. The reader flips a node from human to AI, runs the workflow, and watches execution either block on a remaining human step or flow through to completion.

The argument is the artifact. You can see exactly where automating one slot speeds things up, and where a human is still load-bearing. This was a focused advisory deliverable — a way to make a strategic case concrete and let the client reason about their own processes node by node.

EXECUTABLE GRAPHWORKFLOW MODELINGHUMAN / AI / PROGRAMADVISORY DELIVERABLE
REF: FPA-ENGINE
// THE ENGINE

What flipping a node actually does.

  • Workflows encoded as graphs of typed, dependent nodes.
  • Each node swaps between Human, AI, and Program with one switch.
  • A run executes the graph and surfaces where it blocks vs. flows.
  • Blocking steps make the human-load-bearing slots visible, by consequence.
  • The order to automate emerges from the model, not from a roadmap.
// SECTION: RUN → OBSERVE → DECIDE WHICH KNOB TO TURN

04 // The hard part

FIG. WHERE_LEVERAGE_LIVES
REF: FPA-LEVERAGEA point of leverage in a system: one node whose change propagates through the whole graph

The insight is easy to state and hard to make believed.

Automate one swappable step at a time, keep humans where judgment lives, and let the workflow show you the order. Stated as a sentence, it's a platitude. Turning it into something a finance team could operate — an executable graph where flipping a node has visible consequences — is what made the argument land.

The interactive model does the persuading that a deck never could. It lets the client run the experiment themselves, on their own workflows, and reach the conclusion rather than be told it. Conviction that you produce yourself is the only kind that survives contact with a real process.

REF: FPA-HARD // PERSUASION BY EXECUTION, NOT ASSERTION

05 // Outcome

A working engine for incremental finance automation.

The consultancy walked away with a working interactive model and engine — a concrete, executable framework for deciding which workflow steps to automate, in what order, and where to keep humans in the loop. Directional, by agreement: the value is the method made operable, not a headline metric.

OUT-01
account_tree

Executable model

Their finance workflows encoded as runnable graphs, not slides.

OUT-02
tune

A clear order

Which slot to automate first — and which knob not to touch yet.

OUT-03
groups

Humans kept

The load-bearing judgment slots, made visible and kept on purpose.

OUTCOME: EXECUTABLE MODEL FOR INCREMENTAL FINANCE AUTOMATION // DIRECTIONAL
// NEXT

Have a process you suspect is half-automatable?

We can encode it, run it, and show you which slot to automate first — and where a human is still load-bearing. Names, figures, and proprietary methods are withheld by agreement; we're glad to walk through any of this in more detail under NDA.