How do we set up our first Keboola project to consolidate multiple ERPs + Excel into finance reporting with consistent definitions?

Most finance teams don’t fail on consolidation because of Excel or ERPs. They fail because every entity, system, and spreadsheet carries its own “truth.” If you want 48-hour board packs, fast intercompany reconciliation, and audit-ready trails, you first need one governed place where definitions, data, and automation live together.

Below is a practical, step‑by‑step blueprint for setting up your first Keboola project to consolidate multiple ERPs plus Excel into finance reporting with consistent definitions—without creating yet another brittle stack of scripts and shadow spreadsheets.

---

Quick Answer: The best overall choice for consolidating multiple ERPs + Excel into governed finance reporting is “Single Finance Hub” in one Keboola Project. If your priority is strict isolation by entity or region, “Multi‑Project by Entity” is often a stronger fit. For experimentation or PoCs with AI‑assisted build, consider “Sandbox → Production Promotion”.

---

At-a-Glance Comparison

Rank	Option	Best For	Primary Strength	Watch Out For
1	Single Finance Hub Project	Central finance reporting across entities	One glossary, one truth; shared components, easy governance	Needs clear role/permission model to avoid chaos
2	Multi‑Project by Entity / Region	Highly regulated groups or ring‑fenced entities	Strong isolation, local autonomy, controlled sharing	More setup overhead, requires shared data contracts
3	Sandbox → Production Promotion	Teams testing Keboola or iterating new models	Safe experimentation, then hardened for production	Don’t leave key flows in sandbox; promote or retire them

---

Comparison Criteria

We evaluated these setups using three practical criteria:

• Governance & consistency:
  Can you define one set of business definitions (chart of accounts, FX policy, entity hierarchy) and enforce them everywhere? This includes audit trails, lineage, and permissions.

• Operational simplicity & speed:
  How quickly can you ingest new ERPs, onboard entities, and adjust logic at quarter‑end—without ticketing queues or fragile, hand‑coded glue?

• Scalability & extensibility:
  Does the setup scale from “Phase 1: 2 ERPs + Excel” to “9+ countries, new systems, AI agents in IDEs,” without a full redesign?

---

Detailed Breakdown

1. Single Finance Hub Project (Best overall for central finance reporting)

Single Finance Hub Project ranks as the top choice because it gives you one governed environment where ingestion, transformation, glossary, and outputs are all managed consistently.

In practice, this looks like a single Keboola Project that serves as your group‑wide finance hub. Inside that project you:

• Connect each ERP and Excel source
• Normalize them into a shared finance model
• Define and enforce your group glossary
• Deliver governed outputs (Snowflake, dashboards, files, APIs) from one place

What it does well:

• One glossary, one truth:
  You maintain a single set of controlled reference tables—chart of accounts, cost center hierarchies, legal entities, FX rates, fiscal calendars. Transformations across all ERPs read from the same set of definitions, so “EBITDA” means the same thing in Prague and Singapore. Keboola’s active metadata captures every execution, table, and mapping, so you can show auditors exactly how a KPI was produced.

• Fast onboarding and changes:
  When you add a new ERP or overhaul an allocation rule, you change logic in one place. Flows in Keboola let you chain ingestion → harmonization → consolidation → delivery without extra orchestration tools—no devops, no ticketing delays. With 700+ native integrations plus Generic REST API connectors, you can cover mainstream ERPs and long‑tail systems alike.

• Governed AI‑assisted build:
  You can use the Keboola MCP Server from tools like Cursor, Windsurf, Claude, or ChatGPT to scaffold pipelines, SQL, and Python transformations quickly—but the execution remains deterministic, governed, and auditable inside Keboola. That means you can leverage AI without creating Shadow AI.

Tradeoffs & Limitations:

• Requires thoughtful permissions & structure:
  One hub doesn’t mean one big bucket. You need to structure configurations, folders, and Flows by domain (e.g., “ERP Ingestion,” “Harmonization,” “Consolidation,” “Reporting Marts”) and set roles so that local teams only touch what they own. Keboola’s user and permission model supports this, but you must design it intentionally.

Decision Trigger:
Choose Single Finance Hub Project if you want group‑level reporting with consistent definitions and you’re ready to run multiple ERPs, Excel sources, and finance automations under one governed umbrella.

---

2. Multi‑Project by Entity / Region (Best for strong isolation)

Multi‑Project by Entity / Region is the strongest fit when regulatory, legal, or organizational boundaries demand hard isolation between entities—yet you still want fast, governed consolidation.

In this setup:

• Each major entity/region gets its own Keboola Project.
• Local teams handle ingestion and local transformations.
• A separate “Group Finance Hub” project consumes standardized outputs via secure sharing.

What it does well:

• Regulatory and organizational isolation:
  Sensitive ledgers or jurisdictions (e.g., EU vs. US, regulated entities) can be fully separated at the project level. Role‑based access, audit trails, and security events stay scoped to each project. Data sharing between projects is explicit and controlled, which simplifies conversations with compliance and risk teams.

• Local autonomy, global standards:
  Local controllers can adapt ingestion and minor mappings to the specifics of their ERP or tax rules, while group finance mandates a shared “data contract”: standardized outputs (e.g., normalized GL, COA‑mapped trial balances, FX‑aligned balances) they must expose. Keboola’s secure project‑to‑project sharing ensures that group only consumes governed, production‑ready tables.

Tradeoffs & Limitations:

• More moving parts to manage:
  You’ll maintain multiple projects, each with its own Flows, tokens, and monitoring. To prevent drift, you need clear standards: naming conventions, shared transformations (via Git/dbt packages or code reuse), and a defined process for onboarding new projects. Keboola makes cross‑project sharing straightforward, but governance discipline is non‑negotiable.

Decision Trigger:
Choose Multi‑Project by Entity / Region if you want strict isolation (for compliance or organizational reasons) but still need a governed consolidation hub that can pull standardized data from multiple Keboola Projects.

---

3. Sandbox → Production Promotion (Best for PoCs and iterative build)

Sandbox → Production Promotion stands out for cases where you’re still exploring how to consolidate ERPs + Excel and want to refine your data model and glossary before locking in long‑term structures.

Here, you:

• Start in a “Sandbox” project to experiment with ingestion patterns, transformations, and definitions.
• Once stable, recreate or promote the winning patterns into a dedicated production finance project (often the Single Finance Hub model).

What it does well:

• Safe experimentation with real data:
  You can connect a subset of ERPs and sample Excel files in a Sandbox project, try various mapping strategies, and iterate your chart of accounts and KPI definitions without impacting production processes. SQL & Python workspaces with Dev/Prod mode and version control make it easy to test and roll back changes.

• Cleaner production project:
  Instead of carrying experimental debris into production, you promote only hardened Flows and components. You can use the Keboola CLI and Git to move configurations and transformations from Sandbox to your main finance project, keeping production focused, auditable, and lean.

Tradeoffs & Limitations:

• Risk of “forever sandbox” if not governed:
  If you don’t define a clear promotion path, teams might keep using Sandbox outputs for reporting, effectively creating Shadow IT. The whole point is to prototype fast, then move to deterministic, governed execution in your production project.

Decision Trigger:
Choose Sandbox → Production Promotion if you’re just starting with Keboola, want to prove value quickly, and need to refine your finance model and glossary before committing it to a long‑term governed hub.

---

How to Set Up Your First Keboola Project for Multi‑ERP + Excel Finance Reporting

Now let’s walk through the concrete steps you’d take in the Single Finance Hub setup (the recommended default for most finance teams), using Keboola’s project model and governance features.

Step 1: Define the Use Case and Scope

Before you click “Create Project,” define exactly what this first project will serve:

• Target users:
  Group finance, FP&A, controlling, possibly local finance leads.

• Core reports in scope for Phase 1:

  • Consolidated P&L by entity and segment
  • Balance sheet with group‑consistent hierarchies
  • Cash flow statement (direct or indirect, pick one and codify it)
  • Key KPIs (EBITDA, NIM, contribution margin, etc.)

• Systems and files in scope:

  • ERP A (e.g., SAP) – 3 entities
  • ERP B (e.g., NetSuite or MS Dynamics) – 2 entities
  • Excel workbooks – adjustments, allocations, manual journals, budgets

Document these upfront. In regulated environments, this short scope definition becomes the top of your audit trail: “This project exists to produce X outputs from Y systems under Z policies.”

Step 2: Create a New Keboola Project

In Keboola, create a new project and name it clearly, for example:

• FINANCE-GROUP-HUB
• FINANCE-CONSOLIDATION-PROD

As you create it:

1. Pick the right region and org: Align with your data residency and compliance needs (e.g., EU vs. US).
2. Plan your project structure:
   Use clear sections or tagging for:
   • 01 – Ingestion (ERPs, Excel, other sources)
   • 02 – Staging & Harmonization
   • 03 – Consolidation & Calculations
   • 04 – Data Products & Exports

Keboola Projects provide isolated environments tailored to each business use case. Here, the use case is “group finance consolidation,” not generic data science or marketing analytics—keep the scope focused.

Step 3: Assign Users and Permissions

Governance starts with “who can do what.” In your project:

• Define roles:

  • Data Engineer / Platform Owner – full configuration access, responsible for Flows and infrastructure.
  • Finance Power User – can run Flows, manage some mappings (e.g., account mapping tables), but not change core orchestration logic.
  • Read‑only / Auditor – can see configurations, lineage, and logs, but cannot change flows or data.

• Assign users by responsibility:

  • Group finance team as consumers (and possibly owners of glossary tables).
  • IT / Data team for connectors, transformations, and monitoring.
  • Audit/compliance viewers as read‑only.

Keboola’s access controls and audit trails ensure that every execution, user action, and security‑relevant event is captured. In a CFO’s world, that’s often the difference between “clever automation” and “production‑ready.”

Step 4: Add Data Sources – ERPs and Excel

Now connect your sources.

4.1 Connect ERPs

For each ERP:

1. Use native connectors where available
   Search Keboola’s 700+ native integrations (e.g., for SAP, NetSuite, MS Dynamics, Oracle, Salesforce for subledgers, etc.). Configure credentials with the least necessary privileges.

2. Use Generic REST API connectors for long‑tail systems
   When there’s no native connector, you can still pull data using Keboola’s Generic REST API components. This is critical in multi‑ERP landscapes where smaller or vertical‑specific systems are common.

3. Decide on cadence and method:

   • Batch nightly loads for standard reporting.
   • CDC or Data Streams for near‑real‑time subledger or transaction‑level views, if required.

4. Scope the ERP extracts:
   Focus on:

   • General ledger entries
   • Chart of accounts
   • Dimensions (cost centers, profit centers, projects)
   • Exchange rates if the ERP holds them
   • Entity and legal structure tables

Keep raw tables as close to source as possible in a Raw/Staging layer. Clean later; preserve lineage now.

4.2 Ingest Excel Workbooks

Excel is usually where “shadow finance” lives. Instead of fighting it, put it under control:

1. Configure file‑based inputs:
   Use Keboola’s file storage or connectors (e.g., S3/SharePoint/OneDrive if you centralize files there) to ingest Excel/CSV files for:

   • Manual adjustments
   • Allocations rules
   • Topside entries
   • Budgets and forecasts

2. Enforce templates:
   Define standard templates for local teams: required columns (e.g., Entity, Account, Amount, Currency, Period), data types, allowed values. Keep them in the Data Catalog as data products (“Finance Manual Adjustments Template”).

3. Version and track changes:
   Each file load becomes a governed event in Keboola. You can trace which version of a workbook fed which period’s consolidation.

Step 5: Design the Harmonized Finance Data Model

This is the heart of “consistent definitions.” Start with a clear target model and capture it in Keboola as both:

• Tables and schemas
• Transformation logic (SQL, Python, dbt) tied to shared reference tables

Core components of the model:

1. Shared dimensions (reference tables):

   • dim_chart_of_accounts – group chart, including mapping to local ERPs.
   • dim_entity – legal entities, consolidation groups, currency, jurisdiction.
   • dim_cost_center, dim_product, dim_segment – harmonized across ERPs.
   • dim_fx_rates – official FX rates per group policy.
   • dim_calendar – fiscal periods, weeks, special adjustments.

2. Standardized facts:

   • fact_gl_normalized – GL entries with local chart of accounts but standardized column set.
   • fact_gl_group_coa – GL entries mapped to the group chart of accounts.
   • fact_adjustments – manual and topside entries from Excel.
   • fact_consolidated – final consolidated numbers at chosen grain (entity, period, account, segment).

Store these in a clear “02 – Staging & Harmonization” and “03 – Consolidation & Calculations” layer, not mixed with raw source tables.

Step 6: Build Flows for Ingestion → Harmonization → Consolidation

With the model defined, you orchestrate the process in Keboola using Flows. The objective: deterministic, repeatable execution that you can explain end‑to‑end to an auditor.

Typical Flow structure:

1. Flow: ERP A Ingestion

   • Extract from ERP A connector.
   • Basic cleaning (dates, numeric types).
   • Load into stg_erpA_* tables.

2. Flow: ERP B Ingestion

   • Same pattern as ERP A, but isolated to ERP B tables.

3. Flow: Excel Inputs

   • Ingest manual adjustments and templates.
   • Validate structure and required fields (fail fast if invalid).

4. Flow: Harmonization

   • Transform stg_erp*_gl into fact_gl_normalized using robust SQL/Python.
   • Apply chart of accounts mapping to create fact_gl_group_coa.
   • Apply FX and calendar logic using shared dim_* tables.

5. Flow: Consolidation & Eliminations

   • Run consolidation logic (including intercompany eliminations if in scope).
   • Join ERP‑based facts with Excel adjustments.
   • Produce fact_consolidated for outputs.

6. Flow: Delivery

   • Push structured marts to your data warehouse or BI tools.
   • Publish as data products in Keboola’s Data Catalog.
   • Optionally, expose CSV extracts or APIs for downstream consumption.

You can schedule these flows (e.g., nightly, hourly, or at period‑end) and monitor them via centralized logging. Every run is captured as active metadata—what source tables were used, what transformations ran, how long they took, who triggered them.

Step 7: Implement and Enforce the Finance Glossary

“Consistent definitions” isn’t a slide; it’s a set of controlled tables plus contracts that transformations must follow.

Concretely:

• Centralize glossary tables:
  Treat dim_chart_of_accounts, dim_kpi_definitions, and other finance reference tables as governed data products maintained by group finance in Keboola.

• Lock critical logic:
  Core definitions (e.g., how EBITDA is calculated, which accounts roll up to which KPI) live in transformations under version control. Changes go through review, not ad‑hoc Excel edits.

• Use the Data Catalog for consumption:
  Publish fact_consolidated and relevant dimensions as catalog entries. Business users subscribe to these governed products instead of building their own extracts.

• Trace each KPI to source:
  Use Keboola’s active metadata and lineage to show, for any value in your P&L:

  • Source ERP or Excel file
  • Applied mappings and FX rates
  • Transformations and flows executed
  • Execution logs and timestamps

If a regulator or internal audit asks, “How did you get this number?” you walk them from fact_consolidated to the originating ERP rows.

Step 8: Set Up Monitoring, Cost Control, and Audit Readiness

Once your first flows are live, you need operational guardrails:

• Activity Center for 360° monitoring:
  Monitor executions, failures, runtimes, and spending per project, flow, or component. Optimize every credit instead of guessing which jobs are burning time and money.

• Security events for SIEM:
  Stream logs and security events from Keboola into tools like Splunk, Datadog, or ELK. This closes the loop for risk and security teams.

• Alerts and runbooks:
  Configure alerts for:

  • Ingestion failures from any ERP
  • Missing or malformed Excel files
  • Data quality checks failing (e.g., trial balance not balancing, missing entities)

Tie each alert to a simple runbook: what to check, how to rerun flows, and who owns the fix.

Step 9: Iterate and Expand

After you’ve delivered the first set of governed finance reports:

• Onboard new entities or ERPs:
  Reuse your ingestion and harmonization patterns. For a new ERP, you mainly build:

  • New ingestion flow
  • New set of mappings to your existing dim_* tables

• Add new outputs:
  Create additional data products (e.g., management P&L vs. statutory P&L) by reusing the same underlying governed tables. No duplication, no delays.

• Introduce governed AI workflows:
  Use the Keboola MCP Server to let agents in Cursor or Claude propose new transformations or test new KPIs; keep final execution in Keboola. That way, even AI‑generated improvements run under full governance.

---

Final Verdict

For most organizations asking how to consolidate multiple ERPs and Excel into finance reporting with consistent definitions, a Single Finance Hub Project in Keboola is the right starting point. It centralizes ingestion, harmonization, consolidation, and delivery under one governed environment, with one glossary and one truth.

If you face hard regulatory or organizational boundaries, extend this with a Multi‑Project by Entity pattern and a shared group hub. If you’re still shaping your model, begin with a Sandbox → Production approach to experiment safely, then promote only deterministic, auditable flows.

The common principle across all three options: if a workflow cannot be traced end‑to‑end—from ERP row or Excel cell to final KPI—it doesn’t ship. Keboola gives you the mechanics to enforce that standard while cutting tool sprawl, shrinking month‑end cycles, and keeping AI‑era automation firmly under control.

---

Next Step

Get Started