---
title: "The AI Doesn't Fix the Data: Why Data Strategy Still Makes or Breaks EPM Implementations"
description: A solid data strategy is crucial for successful EPM implementations, plus learn to optimize your planning model for better accuracy and performance.
---

[QueBIT Blog](https://blog.quebit.com/blog)

# [The AI Doesn't Fix the Data: Why Data Strategy Still Makes or Breaks EPM Implementations](https://blog.quebit.com/blog/the-ai-doesnt-fix-the-data-why-data-strategy-still-makes-or-breaks-epm-implementations)

 Written by [Kate Fonville](https://blog.quebit.com/blog/author/kate-fonville) | Nov 17, 2026, 5:09:02 PM

Every planning platform demo now includes AI. Agents that build models, machine-learning forecasts, natural-language questions answered in seconds. It's genuinely impressive, and it's changing how finance, operations, and HR teams work.

> But there's a quieter truth every implementation team knows: the AI doesn't fix the data. A forecast model trained on inconsistent history produces confident-looking wrong answers. An agent that builds a model on top of a messy chart of accounts just builds a messy model faster.

The success of a modern planning implementation, whether it's Pigment, IBM Planning Analytics, or another platform, still depends on decisions made long before anyone opens the modeling canvas. What data exists? Who owns it? How much of it do you actually need? And how will the model hold up when the volume doubles?

If you're preparing for a new implementation, or living with a model that has slowed down over time, this guide is for you. We'll walk through the data questions that most often make or break planning projects, and share a practical framework you can use with your own team right away.

## The four data foundations every planning model depends on

Before a single dimension is built, four questions decide how hard the rest of the project will be. If you spot gaps in one or two, you're in good company. Nearly every organization we work with has them, and they're all solvable when they're found early.

**1. Availability: does the data you need actually exist?** Teams often design the plan they want, then discover the data to support it was never captured. Driver-based revenue planning needs volume and price detail, not just booked revenue. Workforce planning needs position-level data, not just payroll totals. Map every planned input to a real source before you design around it.

**2. Consistency: does it mean the same thing everywhere?** The same customer, product, or department often lives under different codes in the ERP, the CRM, and the HRIS. A reorganized cost center, a renamed product line, or a chart of accounts change mid-year breaks history in ways that only surface when a forecast looks wrong. Consistent hierarchies and mappings are what let a planning model compare like with like.

**3. Ownership: who is accountable when the numbers disagree?** Planning data crosses departments. Finance owns the GL, HR owns headcount, operations owns volumes and capacity. When no one owns the master data and its mappings, every variance review becomes a debate about whose number is right. Name an owner for each source and each shared hierarchy, and agree on how changes get communicated.

**4. Source-system readiness: can the system deliver data the way the model needs it?** Some systems export clean, well-structured data on a schedule. Others need custom saved searches, manual extracts, or cleanup before anything can load. Assess each source for extract method, refresh frequency, and level of detail early. A gap found in week two is a design decision; a gap found in user testing is a delay.

## Why more history and more detail make models bigger, fast

Model size in a multidimensional planning platform doesn't grow in a straight line. It multiplies. Every dimension you add to a metric multiplies the number of potential cells by the number of items in that dimension.

Consider a simple expense metric dimensioned by 500 accounts, 200 cost centers, and 36 months. That's 3.6 million potential cells. Add 50 projects and it becomes 180 million. Keep 10 forecast snapshots for version comparison and you're at 1.8 billion, before a single calculation runs.

Most of those cells will be empty, and modern engines handle sparsity well. But sparsity has limits. Every additional dimension, snapshot, or year of history adds load to calculations, slows imports, and makes the model harder for users to navigate.

Two patterns drive most of the growth we see:

- **Historical snapshots.** Saving every forecast version forever feels safe. In practice, teams rarely compare more than a handful of versions. Archive the rest outside the active model.
- **Transaction-level detail.** Loading invoice lines, individual journal entries, or employee-by-day records into a planning model often adds volume without adding planning value. That detail usually belongs in the ERP or a reporting layer, with the planning model holding summarized data and a drill-through path when someone needs to investigate.

## A practical framework for choosing the right granularity

> The goal isn't the most detailed model. It's the least detailed model that still supports every decision the business needs to make.

Run each proposed dimension or data field through five questions before it goes in.

 

| Question | If yes | If no |
| --- | --- | --- |
| Does someone plan or forecast at this level? | Include it in the planning model | Keep it in actuals reporting only, or leave it out |
| Does a decision change based on this detail? | Include it at the level the decision is made | Summarize to the level where decisions happen |
| Is the source data reliable and owned at this level? | Load it, with a named data owner | Fix it at the source first, or plan one level up |
| Is it needed for every metric, or only a few? | Use it as a shared dimension | Apply it only to the metrics that need it |
| Does it need to live in the model, or just be reachable? | Load it into the model | Hold it in the ERP or a data layer with drill-through |

 

A few rules of thumb fall out of this:

- **Plan at the level people think, report at the level the data exists.** Department heads may budget by cost center and account group while actuals land by individual GL account. Map between the two rather than forcing everyone to plan at the lowest level.
- **Not every metric needs every dimension.** Revenue may need customer and product. Facilities expense almost certainly doesn't.
- **Start lean, then add.** It's far easier to add a dimension once users ask for it than to remove one that slowed every calculation for a year.

## Design calculations for performance, then revisit as data grows

A model that runs in seconds at go-live can slow to minutes a year later. Usually nothing broke. The data just kept growing into a design built for a smaller footprint.

Performance-minded design starts on day one:

- **Calculate at the right level.** Run allocations and driver math at the summarized level where planning happens, not at the transaction level, then push results down only where needed.
- **Avoid chains of near-duplicate metrics.** Long dependency chains, where each metric recalculates from the one before, multiply processing time. Consolidate logic where you can.
- **Separate actuals from plan logic.** Actuals that don't change after close shouldn't recalculate every time someone edits a forecast.
- **Limit calculations to the time horizon that matters.** A three-year forecast doesn't need formulas running across ten years of history.
- **Build for the next year of data, not just today's.** Size the model against expected growth in entities, products, headcount, and history.

The key is to put a review on the calendar. We recommend revisiting model design at predictable moments: after the first full planning cycle, after a major ERP or chart of accounts change, after an acquisition or new business unit, and at least once a year. Each review asks the same things: which dimensions are users actually using, which snapshots can be archived, and which calculations have become the bottleneck.

> This is also where AI earns its place. Once the data foundation is sound, AI modeling agents and machine-learning forecasts can speed up builds and sharpen predictions. They work best on clean, consistent, well-scoped data, which is exactly what a good data strategy delivers.

## What we see in the field

These patterns hold across platforms. Whether a team plans in Pigment, IBM Planning Analytics, or another tool, and pulls actuals from NetSuite or another ERP, the same lessons repeat.

- **Fast-to-build platforms can grow faster than planned.** When adding a dimension takes minutes, models expand without anyone deciding they should. Agree early on which dimensions are shared and how many versions stay live.
- **Mature models need periodic design reviews.** Models that have run for years often carry dimensions, calculation logic, and snapshots no one uses anymore. Cleaning them up can restore performance without a full rebuild.
- **The ERP's structure isn't always the plan's structure.** Subsidiaries, departments, and custom segments set up for transaction processing often need mapping, cleanup, or restating before they work for planning.
- **AI features inherit the foundation.** Modeling agents and forecasting tools speed up the work, but only as far as the structure and data beneath them allow.

Our work with [VDX.tv](https://quebit.com/resources/case-studies/vdx-tv-transforms-integrated-planning/) shows what this looks like in practice. The project brought data from multiple finance, HR, and sales systems into one planning model while the business was also updating its chart of accounts. Treating it as a transformation rather than a like-for-like rebuild helped the team reach one version of the truth across 20 countries and 98% forecast accuracy.

## Build the bridge before you build the model

AI is changing how fast planning models get built and how sharp forecasts can be. It isn't changing the fundamentals. A planning model is only as reliable as the data feeding it, and only as fast as the design decisions behind it.

The teams that get the most from modern planning platforms treat data strategy as part of the implementation, not a cleanup project for later. They know where their data comes from, who owns it, how much detail they truly need, and when to revisit the design as the business grows. None of that requires perfect data on day one. It just requires asking the right questions early, and having people in the room who've answered them before.

That's the role an experienced implementation partner plays: the bridge between the source systems that hold your data and the planning model your finance, operations, and HR teams rely on. Since 2001, QueBIT has delivered more than 2,000 projects helping organizations connect ERP, HR, and operational data to planning solutions that scale, from data strategy and readiness assessments through design, build, and ongoing optimization.

**Planning a new implementation, or living with a model that's slowed down?** We'd be glad to help you sort out where to start. [Talk to a QueBIT expert](https://quebit.com/talk-to-an-expert/) about a data readiness review before your next build.

**Want to strengthen the data foundation first?** As a Rotation Digital company, QueBIT works alongside Rotation Digital's Data & AI and Technology Advisory teams, so you can get help across finance, HR, and sales data in one place. Explore [Data & AI services](https://www.rotationdigital.com/services-data-ai), including the fixed-fee [AI Launchpad](https://www.rotationdigital.com/services-data-ai-ai-launchpad) sprint, or see how we can help you deliver a board-ready technology assessment.

[View full post](https://blog.quebit.com/blog/the-ai-doesnt-fix-the-data-why-data-strategy-still-makes-or-breaks-epm-implementations)

```json
{
  "@context" : "http://schema.org",
  "@type" : "BlogPosting",
  "author" : {
    "@type" : "Person",
    "name" : "Kate Fonville"
  },
  "dateModified" : "2026-11-17T17:09:33.351Z",
  "datePublished" : "2026-11-17T17:09:02Z",
  "headline" : "The AI Doesn't Fix the Data: Why Data Strategy Still Makes or Breaks EPM Implementations",
  "image" : {
    "@type" : "ImageObject",
    "height" : 941,
    "url" : "https://339183.fs1.hubspotusercontent-na1.net/hubfs/339183/Collaborative%20Office%20Brainstorming%20Session.png",
    "width" : 1672
  },
  "mainEntityOfPage" : "https://blog.quebit.com/blog/the-ai-doesnt-fix-the-data-why-data-strategy-still-makes-or-breaks-epm-implementations",
  "publisher" : {
    "@type" : "Organization",
    "logo" : {
      "@type" : "ImageObject",
      "height" : 60,
      "url" : "/hs/hsstatic/content_shared_assets/static-1.4092/img/default-amp-logo.png",
      "width" : 60
    },
    "name" : "QueBIT Blog"
  }
}
```