We’re running Fivetran + dbt + Airflow + a bunch of scripts—how do we simplify the stack without creating a bigger mess?

Most teams don’t wake up one day and decide to own Fivetran + dbt + Airflow + ten years of ad‑hoc scripts. It happens incrementally: one connector here, one DAG there, one “temporary” Python job that suddenly becomes critical to month-end close. Then AI shows up in the mix, and your “modern stack” starts to feel more like a Jenga tower.

The real question isn’t “Which tool do we kill?”
It’s: “How do we simplify this stack without breaking trust in the numbers or creating a new platform monster we can’t control?”

Below is a ranked comparison of three realistic paths forward, based on what I see with finance and ops teams every week.

Quick Answer: The best overall choice for unifying your Fivetran + dbt + Airflow + scripts stack is Keboola as a unified AI & data platform. If your priority is minimizing change and keeping your current tools, Keboola as an orchestration & governance layer on top of your existing stack is often a stronger fit. For teams that want to stay “best-of-breed” at all costs, consider doubling down on modular tools and hardening your current Fivetran + dbt + Airflow setup—but expect higher governance and maintenance overhead.

At-a-Glance Comparison

Rank	Option	Best For	Primary Strength	Watch Out For
1	Keboola as unified platform (replace Fivetran + Airflow + scripts, keep dbt)	Teams ready to reduce tool sprawl and standardize governance	End-to-end ingestion → transformation → orchestration → governance → AI in one governed environment	Migration effort and mindset shift from “tool zoo” to “single platform”
2	Keboola as orchestration + governance layer on top of your current stack	Teams with heavy investment in Fivetran/Airflow who need control fast	Centralized monitoring, governance, and AI-ready flows without immediate rip-and-replace	Some complexity persists; savings and simplification are partial, not maximal
3	Stay modular: harden Fivetran + dbt + Airflow + scripts	Teams strongly attached to best-of-breed and deep in custom infra	Familiar tools, minimal change management	Governance gaps, brittle integrations, and rising maintenance as AI & automation expand

Comparison Criteria

We evaluated each path against three criteria that matter when you’re sitting in front of a CFO or an auditor—not just a whiteboard:

• End-to-end governance and auditability:
  Can you trace any number on a board pack back to source tables, transformations, and runs—with execution logs, lineage, and policies in one place? Does this remain true when AI/agents generate and run workloads?

• Operational simplicity and reliability:
  How many systems, UIs, and “critical scripts” are required to keep the lights on? How quickly can you onboard a new engineer, recover from failures, and roll out new data products without ticketing delays?

• Total cost and scalability in an AI-driven stack:
  Not only license/compute costs, but the cost of maintenance, context switching, and risk. Can you add new sources, entities, and AI use cases without linear growth in tools and glue code?

---

Detailed Breakdown

1. Keboola as unified platform (Best overall for cutting tool sprawl without losing control)

Keboola as a unified AI & data platform ranks as the top choice because it replaces ingestion + orchestration + governance + AI automation in one environment, while still letting you run dbt where it makes the most sense—with full lineage and auditability.

Instead of stitching Fivetran for ingestion, Airflow for orchestration, custom scripts for edge cases, and scattered monitoring, Keboola centralizes the full data lifecycle:

• Ingestion (700+ native integrations + Generic REST API components + CDC + Streams)
• Transformation (SQL, Python, native dbt orchestration)
• Orchestration (Flow builder, dependency management, scheduling, retries)
• Governance (active metadata, lineage, audit trails, policies, SIEM-friendly logs)
• AI delivery (Keboola MCP Server, Data Catalog, reverse-ETL-style delivery)

What it does well:

• End-to-end governance and observability:
  You get active metadata on “every execution, every table, every user.” That means:

  • Lineage from source → ingestion job → dbt model → published data product
  • Central logs for successes/failures, with run context and parameters
  • Audit trails that satisfy internal audit, external regulators, and security teams
  • Security events streamed to tools like Splunk/Datadog/ELK for SOC monitoring
    In an AI-driven world—where tools like Cursor, Windsurf, Claude, or ChatGPT can trigger builds via the Keboola MCP Server—this is the difference between “Shadow AI” and deterministic, governed execution.

• Operational simplicity (no more glue code + reduced vendor zoo):
  Teams use Flow builder to orchestrate end-to-end pipelines with clicks or code:

  • Ingest from Salesforce, NetSuite, SAP, custom REST APIs, etc.
  • Transform via SQL/Python workspaces and/or dbt, in Dev/Prod modes with version control.
  • Trigger downstream jobs, tests, and notifications, all inside Keboola.
    No Airflow infra, no custom schedulers, no cron scripts to remember. One UI, one execution engine, one set of logs.
    Customers report outcomes like:
  • “Cut data tool costs by up to 50%”
  • “80% less maintenance”
  • “Launch projects in days,” not months

• AI-ready architecture, without Shadow AI:
  Keboola’s MCP Server exposes your governed data + flows to AI tools (Cursor, Windsurf, Claude, ChatGPT) while keeping execution deterministic and auditable:

  • AI can help design flows and write transformations.
  • Keboola executes them with clear ownership, logging, lineage, and policies.
  • No agent runs code “somewhere” with no trail; everything is captured in active metadata.
    This lets you scale AI-powered development safely, rather than adding another uncontrolled layer on top.

• dbt, but production-ready and governed:
  Many teams already rely on dbt for transformations. Keboola doesn’t fight that; it operationalizes it:

  • Run dbt Core, Cloud, or hybrid, orchestrated in full pipeline context—no Airflow required.
  • Spin up one-command dev environments with real data in under a minute.
  • Trigger staged dbt jobs, tests, and promotions to production via Git-based flows and Keboola CLI.
  • All with built-in metadata and lineage across ingestion, dbt, and downstream products.

Tradeoffs & Limitations:

• Migration work and mindset change:
  You will need to:
  • Migrate key connectors off Fivetran onto Keboola components (or Generic REST if needed).
  • Move orchestration from Airflow into Keboola Flows.
  • Wrap/replace free-floating scripts with governed components or SQL/Python workspaces.
    This isn’t a “toggle switch” project—but you can phase it:
  1. Start with new use cases in Keboola.
  2. Gradually move high-value, high-risk flows (like financial reconciliations).
  3. Decommission Fivetran/Airflow scripts once equivalent flows run reliably in Keboola.

Decision Trigger:
Choose Keboola as a unified platform if you want fewer moving parts, faster project launches, and finance-grade governance. This is the right move when your goal is “one glossary, one truth”—and you’re ready to consolidate, not just patch over the sprawl.

---

2. Keboola as orchestration + governance layer on top of your current stack (Best for keeping Fivetran/Airflow while regaining control)

Keboola as an orchestration and governance layer is the strongest fit when you’re heavily invested in Fivetran, Airflow, or homegrown pipelines, but leadership is pushing for better control, auditability, and AI readiness—without a big-bang migration.

In this pattern, Keboola becomes the control plane and metadata backbone, not an immediate replacement for all tools.

What it does well:

• Central monitoring and lineage across disparate tools:
  You can:

  • Use Keboola to orchestrate or at least monitor jobs triggered in Fivetran, dbt, and Airflow.
  • Capture execution metadata, lineage, and costs in one place, even if the underlying jobs run outside.
  • Feed Keboola’s active metadata into your governance processes and SIEM.
    This reduces the “who owns what?” chaos without forcing you to re-platform everything on day one.

• Governed AI “front door” for your stack:
  via the Keboola MCP Server, you can:

  • Let engineers work from Cursor/Windsurf/Claude/ChatGPT to design or modify flows.
  • Have Keboola coordinate and log all executions—even when they involve calling Fivetran or dbt Cloud APIs.
  • Maintain deterministic, auditable pipelines while still giving developers AI-powered productivity.

• Incremental rationalization over time:
  Once Keboola is your orchestration/governance backbone, you can:

  • Start building new flows directly in Keboola using native components and Generic REST connectors.
  • Gradually move high-cost or brittle Fivetran connectors into Keboola, where you control cost and logic.
  • Shift Airflow DAGs into Keboola Flows when they’re due for refactoring.
    You’re not forced into an all-or-nothing move; instead, you optimize where the ROI is clearest (e.g., complex finance consolidations, multi-entity reconciliations).

Tradeoffs & Limitations:

• Partial simplification, not full consolidation:
  You’ll still:
  • Pay for and operate Fivetran and/or Airflow.
  • Maintain some parallel UIs and concepts (DAGs vs Flows, connectors vs components).
  • Carry legacy scripts that may or may not be fully visible unless you wrap them.
    This option improves control and visibility but doesn’t deliver maximum cost or complexity reduction.

Decision Trigger:
Choose Keboola as an orchestration + governance layer if your priority is to regain control and auditability quickly, while preserving your current tools and spreading migration work over time. It’s the pragmatic choice when political or contractual constraints make a full consolidation hard in the short term.

---

3. Stay modular: harden Fivetran + dbt + Airflow + scripts (Best for teams deeply committed to best-of-breed tools)

Doubling down on your current Fivetran + dbt + Airflow + scripts stack stands out when your organization is philosophically attached to a modular approach or heavily invested in internal platforms around these tools.

You accept the sprawl and work to manage it better, rather than consolidating.

What it does well:

• Minimal change disturbance in the short term:

  • Your engineers keep using the tools they already know well.
  • Your existing Airflow DAGs, Fivetran connectors, and dbt projects remain largely intact.
  • Stakeholders see continuity in the short term, which can be politically easier.

• Deep specialization in each tool:

  • Fivetran remains focused on ingestion.
  • dbt remains your transformation engine.
  • Airflow stays your orchestration and glue layer.
    If you have a platform team that lives and breathes these tools, they can squeeze a lot of value out of them.

Tradeoffs & Limitations:

• Governance and auditability remain fragmented:
  Even with best practices, you’re still dealing with:

  • Lineage split across Fivetran logs, dbt docs, Airflow DAGs, and ad-hoc scripts.
  • Multiple permission models and policy surfaces.
  • Gaps when AI or agents start generating code/jobs outside of the standard paths.
    For finance, risk, and regulated environments, this is exactly where trust starts to erode—people aren’t sure which numbers to believe.

• Operational overhead and “tool tax” keeps climbing:

  • Each new use case tends to add another DAG, another script, another secret.
  • Onboarding new engineers requires teaching them your unique combination of tools and glue code.
  • Incident response means chasing issues across 3–5 systems.
    As AI workflows expand, your brittle junction points expand too.

• AI integration often increases Shadow IT risk:

  • Engineers experiment with AI-generated scripts executed directly on warehouses or servers.
  • There’s no single execution backbone collecting metadata, lineage, and costs.
  • Governance is bolted on, not built in.
    This is where I typically draw the line: if we can’t explain a critical workflow end-to-end to an auditor, it doesn’t ship. That’s becoming harder, not easier, in a tool-zoo world.

Decision Trigger:
Choose “stay modular and harden what you have” only if you have a strong platform engineering function, very high tolerance for operational overhead, and limited regulatory pressure. If you’re in multi-entity finance, regulated services, or board-level reporting cycles, this usually becomes a short-term holding pattern rather than a sustainable strategy.

---

Final Verdict

If your stack is already Fivetran + dbt + Airflow + scripts, you’re not alone—but you’re also at an inflection point.

• If you want fewer tools, clearer ownership, and finance-grade governance, use Keboola as the unified platform and gradually replace Fivetran, Airflow, and brittle scripts. You keep dbt (and make it production-ready and auditable), while gaining end-to-end lineage, active metadata, and AI-ready execution.

• If you need control now but can’t rip things out yet, run Keboola as an orchestration + governance backbone on top of your existing stack. Centralize monitoring, governance, and AI access first; consolidate tools gradually as projects evolve.

• If you choose to stay modular, recognize it as a tradeoff: more flexibility in tooling, less control and higher maintenance—especially as AI plays a bigger role. It can work, but you’ll pay for it in engineering time, audit prep, and incident complexity.

From a risk and operations standpoint, the safest way to simplify without creating a bigger mess is to centralize execution, metadata, and governance—then let tools like dbt plug into that backbone. That’s exactly what Keboola is designed to do: turn every question into a governed, reusable automation, instead of another one-off script.

Next Step

Get Started