How can we let analysts use AI to speed up pipeline work without creating shadow AI, unreviewed code, or un-auditable changes?

Most data teams want the same thing right now: let analysts move 10x faster with AI, without waking up six months from now to a pile of untraceable jobs, mystery dbt models, and “who approved this?” incidents.

You don’t have to choose between AI speed and control. You need a pattern: AI as a productivity layer on top of deterministic, governed execution—not as a separate, shadow stack.

In this guide, I’ll walk through how to:

• Give analysts AI superpowers in tools they already use (Cursor, Windsurf, Claude, ChatGPT).
• Keep every pipeline change reviewable, auditable, and reproducible.
• Eliminate “Shadow AI” by design—no side scripts, no invisible agents, no rogue pipelines.

All examples assume Keboola as the execution layer, but the principles are broadly applicable. I’ll call out where Keboola’s mechanics (MCP Server, Flows, active metadata, Activity Center, etc.) give you a shortcut.

---

The real risk isn’t AI. It’s AI without a spine.

Shadow AI doesn’t start with bad intentions. It starts like this:

• An analyst asks ChatGPT to write a Python script.
• They run it on their laptop against production.
• The script writes to a warehouse table with no lineage, no owner, no review.
• Six months later, finance discovers the board deck is built on that table.

The problems are structural:

• No single execution plane. Code runs “wherever” (local machines, notebooks, random cloud functions).
• No model of ownership & lineage. You can’t answer “who touched this data and how?”
• No policy guardrails. PII handling, access control, and approvals live in docs, not in the system.

If you fix those three, you can safely let analysts use AI as aggressively as you like.

---

Target state: AI is how work is specified, Keboola is where work is executed

The pattern I push with teams is simple:

AI can suggest and scaffold. Keboola runs and governs.

That means:

• Analysts talk to AI (Cursor, Windsurf, Claude, etc.).
• AI interacts with Keboola through the Keboola MCP Server, not directly with your warehouse.
• Every pipeline ends up as a Flow, SQL/Python transformation, or component configuration inside Keboola.
• Execution is deterministic, logged, and auditable—exactly like if an engineer built it by hand.

While others stop at “AI writes code,” this is about “AI writes pipelines that ship, with audit trails.”

---

1. Centralize execution: no pipeline outside Keboola

The first non‑negotiable: if a workflow touches production data, it runs in a governed platform—not on someone’s laptop or a hidden notebook.

With Keboola, that means:

• All ingestion goes through 700+ native integrations or Generic components (e.g., Generic REST API connector).
• All transformations run as Keboola transformations (SQL/Python) in Flows, not as ad-hoc scripts.
• All orchestration is via Flow builder, not cron jobs scattered across servers.
• All AI‑generated logic lands in those same constructs.

Operationally:

• Analysts can still prototype locally, but anything that becomes “how the business works” must be rebuilt or promoted into Keboola.
• You treat “off‑platform” scripts as exceptions that have to be justified, not the default.

This gives you one place where:

• Every job execution is logged.
• Every table has lineage.
• Every cost is attributable to a project or Flow.

Now AI has somewhere safe to plug in.

---

2. Plug AI into Keboola with the MCP Server (not straight into your warehouse)

The gateway between AI tools and your data pipelines should be Keboola, not the database directly.

Keboola’s MCP Server is built exactly for this:

• You connect tools like Cursor, Windsurf, Claude, ChatGPT to Keboola.
• From within those tools, AI can:
  • Create new Flows and components.
  • Configure integrations via Generic REST API connectors.
  • Generate or edit SQL/Python transformations.
  • Inspect execution logs and suggest fixes.
  • Auto‑document what it created.

Crucially:

• AI is never running arbitrary code against your production systems by itself.
• It’s calling explicit, governed actions inside Keboola (“create transformation,” “run Flow,” “fetch log”), with audit trails.

So instead of “analyst + ChatGPT + warehouse credentials,” you get:

Analyst + AI IDE (Cursor/Windsurf/Claude) → Keboola MCP Server → Keboola Flows → Warehouse

Every hop after the IDE is controlled, logged, and policy‑aware.

---

3. Enforce human review and Dev/Prod separation

AI can draft a pipeline in seconds. That doesn’t mean it should go to production in seconds.

You need structure:

Use Dev/Prod mode and branching

In Keboola:

• Analysts work in Dev mode or dedicated branches.
• AI-generated changes are made in Dev:
  • New transformations.
  • Flow modifications.
  • Integration configs.
• Promotion to production is explicit and reviewable.

This gives you:

• Safe experimentation: Analysts and AI can iterate quickly.
• Traceable promotion: You can see exactly what changed when you merge to Prod.

Require review for sensitive Flows

For critical domains (finance, risk, regulatory reporting), set a policy:

• No change to these Flows ships without:
  • A human owner.
  • A second pair of eyes (reviewer).
  • At least a minimal test (row count check, reconciliation check, or validation query).

Because everything is in Keboola, that review can happen at the Flow / component level, not by hunting through random repos.

---

4. Make every AI action auditable: logs, lineage, and metadata

If you can’t explain a pipeline to an auditor from source → transformation → output, it doesn’t ship. AI doesn’t change that rule; it just changes how fast you can get to a reviewable pipeline.

Keboola gives you the backbone:

• Active metadata: “Every execution, every table, every user” is captured:
  • Which Flow ran.
  • Which components and transformations were used.
  • Which user or agent triggered it (including via MCP Server).
• Data lineage: You can trace:
  • Source systems → tables → transformations → final outputs.
  • Downstream consumers via the Data Catalog (who subscribed, what they’re using).
• Activity Center: 360° monitoring:
  • Spend by project, Flow, and component.
  • Performance and failure patterns.
  • Security‑relevant events that can stream to Splunk, Datadog, ELK, etc.

Operationally, this solves the “un‑auditable change” problem:

• If AI creates a new transformation, you know when, how, by whom (or which agent).
• If AI modifies an existing Flow, that’s a versioned, visible change.
• If an auditor asks “why is this number here?”, you can walk back through each execution step.

---

5. Lock down access and policies so AI can’t leak or misuse data

Governance isn’t a luxury in an AI‑driven world; it’s the only way to move fast without getting burned.

Keep AI within your access model

In Keboola:

• AI agents using the MCP Server are just another “user” type:
  • They inherit permissions.
  • They’re scoped to projects.
  • They don’t magically bypass role‑based access control.
• Data access is controlled at the platform level, not in the AI tool.

That means:

• An analyst’s AI agent can’t pull data they couldn’t pull themselves.
• If a project should never see raw PII, AI can’t “accidentally” surface it.

Codify policy in the platform, not in a doc

Examples:

• Use project boundaries to separate regulated environments (e.g., credit risk, regulatory reporting).
• Use standardized components for sensitive tasks (e.g., masked CDC feeds) instead of ad‑hoc scripts.
• Use the Data Catalog to publish “gold” products:
  • Consumers subscribe with one click.
  • They don’t recreate logic, which reduces the surface area for AI‑generated drift.

This shifts you from “we hope people follow the rules” to “the system enforces the rules.”

---

6. Use AI where it’s safest and highest ROI

You don’t need AI to touch everything on day one. Start with tasks where:

• The risk is low.
• The output is easy to inspect.
• The productivity gain is immediate.

Great early use cases

1. SQL generation & refactoring
   • Analysts describe the metric in natural language.
   • AI (via MCP Server) drafts the SQL transformation.
   • Analyst reviews, tests, and promotes in Keboola.
2. Pipeline boilerplate
   • AI creates Flows to move data between systems using native connectors or Generic REST API.
   • It sets up incremental logic, schedules, and basic monitoring.
3. Error analysis & runbook suggestions
   • When a Flow fails, AI reads logs and suggests fixes.
   • Analyst reviews fix and applies in Dev.
4. Documentation
   • AI auto‑generates runbooks, descriptions, or lineage notes based on existing Flows and transformations.
   • Documentation lives alongside the assets in Keboola.

These are all “human + AI, working as one”: AI proposes, human disposes, platform executes.

---

7. Ban Shadow AI by making the official path faster

You can’t stop analysts from experimenting with AI. But you can make the official path easier, faster, and safer than going rogue.

Practical steps:

• Standardize on Keboola + MCP Server as the sanctioned way to use AI for pipelines.
• Make access easy:
  • Provide templates and example prompts for Cursor/Windsurf/Claude connected to Keboola.
  • Pre‑configure a “sandbox” project where analysts can safely try things.
• Instrument everything:
  • Use Activity Center to watch where AI‑assisted work is happening.
  • Track execution volume, costs, and error rates for AI‑built Flows vs manually built ones.
• Educate with guardrails, not fear:
  • “Use AI as much as you want—inside Keboola, where it’s logged and governed.”
  • “If it runs outside Keboola, it’s a prototype, not production.”

When the official path is “chat, it builds, it runs—governed, repeatable, ready for production,” Shadow AI loses its appeal.

---

What this looks like in practice (a finance example)

Take a multi‑entity finance team struggling with month‑end:

• They need to ingest GLs from 9 countries.
• Normalize charts of accounts.
• Run inter‑company eliminations.
• Produce board‑ready metrics in 48 hours, not two weeks.

With Keboola and AI:

1. Integration
   • Analyst tells AI in Cursor: “Set up ingestion from these 9 GL systems into Keboola, daily, with CDC where possible.”
   • AI, via MCP Server, configures Flows with native connectors and Generic components.
2. Transformation
   • AI scaffolds normalization and consolidation logic as SQL/Python transformations.
   • Analyst validates mapping rules and reconciliations in Dev.
3. Governance
   • Every step is in a Flow with full lineage and audit trails.
   • Activity Center monitors spend and performance.
   • Security events (access, changes, failures) stream to SIEM.
4. Delivery
   • Governed data products are published in the Data Catalog.
   • FP&A and business leaders subscribe with one click—no duplication, no delays.

Outcome: Board reporting in 48 hours, month‑end agenda down by ~70%, and not a single unreviewed script hiding under someone’s desk.

---

Implementation checklist: AI speed, zero Shadow AI

If you want a concrete starting point, use this checklist:

1. Centralize execution

   • All production data movements run in Keboola Flows.
   • No direct warehouse access for AI agents; they connect via Keboola MCP Server.

2. Set up AI integration

   • Connect Cursor/Windsurf/Claude/ChatGPT to Keboola via the MCP Server.
   • Provide example prompts and starter Flows for analysts.

3. Define environments & reviews

   • Dev/Prod separation enforced for all projects.
   • Review required for changes to critical Flows (finance, risk, regulatory).

4. Harden governance

   • Role‑based access and project boundaries configured for sensitive data.
   • Data Catalog used to publish “gold” data products.
   • Activity Center wired to your SIEM (Splunk/Datadog/ELK) for security events.

5. Roll out safe AI use cases

   • Start with SQL generation, boilerplate Flows, error analysis, and documentation.
   • Measure time‑to‑build, error rates, and maintenance effort before/after.

6. Decommission Shadow AI

   • Inventory external scripts/notebooks hitting your warehouse.
   • Rebuild critical ones as Keboola Flows.
   • Close off direct paths to production for ad‑hoc automation.

---

Final verdict

You can absolutely let analysts use AI to move 10x faster on pipelines—if AI is plugged into a governed spine.

Make Keboola the single execution plane, connect AI through the MCP Server, enforce Dev/Prod and reviews, and lean on active metadata, lineage, and Activity Center for observability. That’s how you eliminate Shadow AI, keep auditors happy, and still ship governed, AI‑assisted pipelines in days—not months.

Next Step

Get Started