How do I sign up for Keboola’s Free plan (no credit card) and start a proof of concept?

Most teams don’t fail their first data or AI proof of concept because of ideas. They fail because setup drags on, access is blocked behind credit cards and tickets, and governance questions appear only after something breaks. The Free plan in Keboola is built to flip that: fast start, no credit card, and a governed path from first demo flow to production‑ready automation.

Below is a step‑by‑step guide to sign up for Keboola’s Free plan and turn it into a realistic proof of concept (PoC) you can show to stakeholders or auditors—without touching a procurement form.

---

1. What you get with Keboola’s Free plan

Before signing up, it helps to be explicit about what you’re testing.

With the Free plan, you can:

• Run your data operations on a single, unified platform
  Ingest, transform, orchestrate, govern, and deliver data and AI workflows in one place—no stack assembly, no glue code.

• Start instantly with no credit card
  Create a project, connect a source, and build Flows without going through purchasing or internal billing.

• Use core features free forever
  Enough capacity to build a serious proof of concept, test end‑to‑end governance, and validate performance.

• Expand later with additional credits
  When your PoC is ready, you can scale usage without rebuilding your pipelines in another tool.

This is ideal for:

• Data teams consolidating scattered ETL/ELT + orchestration into one governed platform.
• Finance and risk teams needing a traceable PoC for board reporting, inter‑company reconciliation, or regulatory audits.
• AI/analytics teams wanting to build governed workflows triggered from tools like Cursor, Windsurf, Claude, or ChatGPT via the Keboola MCP Server.

---

2. How to sign up for Keboola’s Free plan (no credit card)

You can get from “I’m curious” to a live project in a few minutes. No payment details, no contract.

Step 1: Go to the signup page

1. Open your browser and go to keboola.com.
2. Click “Try now” or “Run your data operations on a single, unified platform”.
   Both lead you into the self‑service signup flow.

You don’t need to use the “Request a Demo” form for the Free plan—even though you’ll see it in other parts of the site. That form is for guided demos; the Free plan signup is direct and self‑service.

Step 2: Create your Keboola account

On the signup screen:

1. Enter your work email

   • Use your business domain (e.g., @company.com) rather than personal Gmail/Yahoo.
   • This makes it easier to prove value internally and later invite colleagues under the same organization.

2. Set your password and confirm.

3. Accept the terms and privacy policy.

4. Submit the form.

   • You’ll receive a verification email; click the confirmation link to activate your account.

No credit card. No “talk to sales first.” Once your email is verified, you can immediately create your first project.

---

3. Create your first Keboola Project for the PoC

After confirming your account, Keboola will prompt you to create a Project. Think of a Project as a governed workspace with its own integrations, Flows, data, and access rules.

Step 1: Name and scope your project

Define your PoC in a way that maps to a real business process. For example:

• Board Reporting – Single Source of Truth
• Month-End Close – Intercompany Reconciliation
• Customer 360 – Marketing + Finance
• AI-Powered KPI Assistant – Governed

In my experience, the PoCs that get funded are the ones that mirror actual workflows, not abstract “data lakes.”

When creating your Project:

1. Give it a clear, business‑oriented name.
2. Optionally add a description: what you’re proving, which systems you’ll integrate, and who the internal sponsor is.

Step 2: Choose region and basic settings

Pick the region closest to your primary users or compliance requirements (e.g., EU for GDPR‑heavy organizations). This helps with latency and governance alignment.

Once you confirm, your empty Project will be ready and you’ll land in the Keboola UI.

---

4. Plan your proof of concept in 30 minutes

Before you start clicking connectors, define a tight PoC scope. A Free plan shines when you use it to prove a complete “question → governed automation → answer” loop.

Use this simple PoC checklist:

1. Primary question

   • Example: “Can we consolidate all entities’ trial balances into one governed board reporting dataset within 48 hours?”

2. Systems in scope

   • ERP / GL (e.g., SAP, Oracle, NetSuite)
   • CRM (e.g., Salesforce, HubSpot)
   • Marketing platforms, payment processors, or operational systems

3. Target outputs

   • A curated table or model (e.g., finance.board_reporting_mart)
   • A Data Catalog product with a clear description and ownership
   • A downstream BI dashboard or an AI agent use case

4. Governance requirements

   • End‑to‑end lineage for all tables
   • Audit trails for job runs and code changes
   • Ability to export logs to SIEM (Splunk/Datadog/ELK) in a later stage

Once this is clear, you can use the Free plan to build just enough to prove:

• Speed of delivery
• Governance quality
• Operational reliability
• Cost visibility

---

5. Connect data sources on the Free plan

While others stop at data movement, Keboola pushes you from connection to governed operation. Start with at least one transactional system and one “consumer” tool.

Step 1: Use native integrations

Keboola offers 700+ native integrations. In your Project:

1. Go to Components or directly to Flow builder and click “Add component”.

2. Search for your source (e.g., Snowflake, BigQuery, PostgreSQL, MySQL, Salesforce, HubSpot).

3. Configure credentials:

   • For databases: host, port, database, username, password, or key‑based auth.
   • For SaaS APIs: OAuth or API keys.

4. Test the connection and save.

Each extraction will be:

• Logged with execution details
• Linked to specific configurations
• Available for lineage and cost tracking later

Step 2: Cover long‑tail APIs with Generic components

If your system isn’t in the 700+ native integrations, use Generic REST API connectors:

1. Add a Generic REST component.
2. Define:
   • Base URL
   • Authentication (Bearer token, Basic auth, etc.)
   • Pagination strategy
   • Endpoints (e.g., /transactions, /customers)
3. Map responses into tables.

This is how we routinely integrate in‑house systems, long‑tail fintech APIs, or niche tools in financial institutions—without waiting for a custom connector.

---

6. Build your first Flow: ingestion → transformation → delivery

Flows are where your PoC becomes a governed, reusable automation.

Step 1: Create a Flow

1. Go to Flows and click “Create Flow”.
2. Name it based on the process, not the technology, for clarity:
   • Month-End Close – Entity Consolidation
   • Customer Revenue Insights – Weekly Refresh

Step 2: Add ingestion steps

Drag your ingestion components into the Flow:

• GL / ERP extract
• CRM extract
• Operational system extract

Configure schedules (e.g., hourly, daily) or trigger manually during the PoC.

Step 3: Transform data in SQL or Python

Use Keboola’s SQL & Python workspaces to define transformations:

• Standardize schemas and reference data (chart of accounts, entity mapping).
• Clean and enrich data (currency conversions, entity mapping, product hierarchies).
• Aggregate to your reporting or AI‑ready level.

Key governance features you get automatically:

• Dev/Prod mode & branching: experiment safely, promote only validated changes.
• Version control: track who changed what and when.
• Lineage: trace each output table back to its sources and transformations.

Step 4: Deliver data and AI‑ready outputs

Depending on your PoC, set up outputs to:

• BI tools (e.g., Tableau, Power BI, Looker).
• Operational databases or data warehouses.
• AI workflows via the Keboola MCP Server (so agents in Cursor/Windsurf/Claude/ChatGPT call governed pipelines, not ad‑hoc scripts).

This is where you prove that your PoC is more than a demo: it’s wired into real tools your stakeholders already use.

---

7. Use AI safely with the Keboola MCP Server (optional but powerful for the PoC)

Many PoCs now involve AI agents generating code or triggering jobs. The risk: Shadow AI—automation running outside IT’s oversight.

On the Free plan, you can already demonstrate a safer pattern:

1. Connect your IDE or AI tool (e.g., Cursor, Windsurf, Claude, ChatGPT) via the Keboola MCP Server.
2. Let the AI help you:
   • Draft component configurations.
   • Generate SQL/Python transformations.
   • Compose new Flows.
3. Keep execution deterministic and governed inside Keboola:
   • Every job is logged.
   • Every table is traceable.
   • Every token and run is attributable to a user/project.

This is compelling in boardrooms and risk committees: “Yes, we use AI to move faster—but every step is auditable.”

---

8. Turn your PoC data into a governed product

To show that your PoC can scale, don’t stop at tables. Turn your curated outputs into data products.

Step 1: Register outputs in the Data Catalog

1. Identify the key tables your PoC produces (e.g., finance.board_reporting_mart, risk.default_exposure_by_segment).
2. Publish them into the Data Catalog:
   • Add a business description.
   • Define an owner (e.g., “Finance CoE”).
   • Tag them by domain (Finance, Risk, Operations).

Step 2: Enable one‑click subscription

Consumers across teams can then:

• Discover the product once in the Catalog.
• Subscribe without duplicating data.
• Always work on the latest, governed version.

This addresses the “one glossary, one truth” problem: board, finance, and business teams see the same numbers generated by the same governed process.

---

9. Prove governance, observability, and cost control

Executives rarely approve scaling a PoC based on speed alone. They want control.

On the Free plan, you can already demonstrate:

• Audit trails
  Every execution, every user, every table is logged. You can walk an auditor from source record to final metric.

• Active metadata
  Keboola treats metadata as live: job runs, table dependencies, user actions. This underpins lineage, governance, and automation.

• Activity Center (when you scale up)
  As you move beyond PoC, Activity Center gives 360° monitoring and “Optimize Every Credit” dashboards. In the PoC phase, highlight that cost attribution and observability are built into the platform design.

The message to stakeholders: you’re not building another black‑box pipeline—this is designed for regulated, multi‑entity environments from day one.

---

10. When and how to move beyond the Free plan

A good PoC usually reaches one of these points:

• You’ve proven a high‑value use case (e.g., board reporting in 48h, –70% end‑of‑month agenda, customer 360 for marketing + finance).
• You want to onboard more entities or regions.
• You need higher capacity or enterprise features (e.g., SIEM integration, advanced security settings, more projects).

At that moment:

1. Share your PoC results internally: time saved, reliability improvement, audit readiness.
2. Use Keboola’s quantified customer examples:
   • Home Credit consolidating across 9 countries.
   • Creditinfo with –70% end‑of‑month agenda.
   • Firehouse Subs with 683% ROI and 2.5‑month payback.
3. Talk to Keboola about upgrading—without rewriting your PoC. The same Project can be scaled; you don’t throw away what you built.

---

11. Summary: turning a Free plan into a credible PoC

To recap the path:

1. Sign up on keboola.com with your work email – no credit card needed.
2. Create a Project that maps to a real business process (board reporting, month‑end, customer 360, AI assistant).
3. Connect sources using 700+ native integrations and Generic REST components.
4. Build Flows that run end‑to‑end: ingestion → transformation → delivery.
5. Optionally use AI via the Keboola MCP Server, with deterministic, auditable execution.
6. Publish outputs as data products through the Data Catalog so stakeholders share one truth.
7. Demonstrate governance and observability to win trust from finance, risk, and audit.
8. Scale up once your PoC proves time savings, reliability, and cost control.

If a workflow can’t be traced end‑to‑end and explained to an auditor, it doesn’t ship. Keboola’s Free plan lets you prove the opposite: you can move fast, leverage AI, and still maintain full control from day one.

Next Step

Get Started