Sage Intacct Planning: Rethinking Financial Formulas

Simplifying complex financial modeling — patent pending design

Brief

Formula logic sits at the core of financial planning, but in most tools, it's treated as a text problem. Users are expected to write expressions from memory, reference accounts and dimensions they may not fully understand, and debug issues only after formulas are applied to live data. As planning models grow in dimensionality, this approach breaks down: errors become harder to trace, logic becomes fragmented across plan lines, and only a small subset of users can confidently build or maintain formulas.

The goal was not to simplify formulas. It was to make complex logic buildable, readable, and reliable at scale.

Part of a bigger system

Formulas don't exist in isolation. In the layered planning architecture, structure defines what exists, models define how metrics behave, drivers control variability, and formulas apply adjustments across the system. In legacy tools these boundaries blur: logic leaks into plan lines, mixes with structure, and becomes difficult to audit or reuse.

This project focused on making formulas behave as a first-class layer — consistent with the rest of the system and the broader planning architecture. (See Planning Architecture for more context)

Challenges

Across leading FP&A platforms, formula authoring follows the same pattern: text-first input, syntax-dependent, dimensional logic embedded inside expressions, validation only after execution. This makes formula creation powerful, but fragile.

Writing a formula requires users to know which accounts are valid, understand dimensional relationships, apply correct syntax, and anticipate downstream impact. The system assists with none of this.

As a result: errors are discovered late, logic breaks silently when upstream changes, reuse is limited, and debugging becomes a specialist task.

This isn't a usability issue. It's a model visibility problem.

My Role

Senior UX Designer, working across two product and engineering teams, in close collaboration with product managers, the VP of Product, and FP&A domain experts.

I led the design of the formula interaction model: from early concept through to the guided assembly approach that was adopted across the Planning domain. This included shaping how formulas are created, validated, and maintained, and aligning the experience with the broader layered architecture.

I worked closely with engineering to translate the interaction model into reusable, scalable components — later extended to drivers, models, and global formulas — while maintaining control over design system growth and consistency.

What I did

The solution was to replace the text field with a guided assembly flow. Instead of authoring logic from memory, users start from a plan line, select a valid account, then select available dimensions in the correct order, with operators and additional logic added once the base is complete.

At each step, the system reflects the structure back to the user. Only valid options appear. Invalid combinations don't exist in the interface because the data model doesn't allow them. What was a syntax problem became a selection problem.

The system doesn't just validate at creation, it stays live. When a referenced plan line changes, the formula re-evaluates immediately. If an upstream change would invalidate a downstream dimension, that selection is surfaced and the user is blocked from saving inconsistent logic.

This is the core of the patent-pending interaction model: errors prevented by design, not reported after the fact. It shifts the burden from user memory to system awareness.

The same principle extended to version merge: one of the highest-stakes actions in the system. Rather than a single confirm dialog, the merge flow gives users granular control over which changes to promote, surfaces formula dependencies and conflicts inline, and offers a full pre-merge preview of the base plan before anything is committed.

Results

The pattern proved robust enough that it didn't stay in formula creation. The same guided, model-aware assembly approach was adopted across drivers, models, global formulas, workforce planning, and navigation, becoming the foundation for how logic is built and managed across the entire Planning domain.

Enterprise-grade formulas that are faster to build, far harder to break, and dramatically easier to reason about — without sacrificing modeling power.

Same power. Zero guesswork.