Builder's Hub Podcast

An airline chatbot promised a bereavement refund the real policy didn't allow. A coding agent ignored a code freeze and wiped a live database of 1,200+ executive records. An MCP server let some customers see other organizations' tasks and comments for about a month.

In this special Halloween episode, Jeremy and Nate unpack what went wrong in these scary integration and AI stories.

What you'll learn:

▸ Why the Air Canada chatbot failed: too little access to real-time data

▸ Why the Replit incident is the opposite problem: too much access

▸ How a tenant isolation bug in Asana's MCP server exposed cross-org data

▸ How a custom data pipeline silently dropped records into a finance system

▸ Why integrations should be built for your peak day, not your average Thursday

▸ Why archiving instead of deleting turned an over-eager Slack cleanup bot into a recoverable mistake

▸ The three controls every story points back to: connect AI to the source of truth, limit what it can touch, and keep visibility into what it's doing

Every story here traces back to the integration layer: what AI can see, what it can touch, and whether anyone can see what it did. Celigo gives AI agents governed, auditable access to enterprise systems, with permissions and guardrails set before anything runs.

👉 Get a demo: https://www.celigo.com/request-a-demo/

A CFO signs off on numbers that go to the board, the auditors, and investors. In order to let AI near the books, they need to know how to get started without exposing the company.

What you'll learn:

▸ What an auditable path for an AI agent looks like: every action logged, exportable, and printable

▸ Why accountability for AI errors usually starts with IT and infosec, and where finance steps in to interpret what happened

▸ How a client went from five days of monthly subledger-to-GL reconciliation to about an hour

▸ How to scope an MCP connector narrowly and expand from there

▸ How agentic workflows can turn meeting transcripts and chat history into SOPs and process flow documentation for audit support and new-hire onboarding

If you're building AI into finance workflows, the order matters: governance and traceability first, a small scoped use case second, then scale.

👉 Get a demo: https://www.celigo.com/request-a-demo/

AI has supercharged the IT leader's workload. High-quality data is essential to that work.

In this episode, Nate sits down with Ray, Celigo's Head of Data, to discuss how to architect a data stack from scratch, when real-time infrastructure is worth the cost, the difference between ETL and ELT, and why AI has turned data quality from a hygiene problem into a governance risk.

What you'll learn:

• Why AI raises the stakes on data quality
• How AI usage affects data and IT workflows day to day
• ETL vs. ELT
• Why real-time vs. batch is a cost and governance decision
• A step-by-step framework for architecting a data stack from scratch

Enjoying Builder's Hub? Subscribe on your favorite podcast app so you never miss an episode, and if you know someone who'd get value out of this conversation, send it their way.

👉 Get a demo of Celigo: https://www.celigo.com/request-a-demo/

When Yash first joined Therabody as CTO, he found a tech stack that had grown by accumulation rather than by design.

Three years later, Therabody runs hundreds of integration flows, sells across marketplaces on multiple continents, and treats a Kendall Jenner campaign launch as a forecastable load instead of an emergency.

This episode gets into the architectural review Yash ran on arrival, the criteria that decide whether any application makes it into the stack, what companies miss when they turn on a new channel, and where the order flow actually breaks when volume spikes.

In this episode:

• The criteria every application has to clear before it enters Therabody's tech stack
• Why post-purchase is where channel launches fails
• How Therabody picks the next marketplace
• Why every marketplace needs a business owner on the sales team, not in IT
• What "ready for peak" means when peak runs all year
• Where the order flow breaks first, and the three layers that keep a spike invisible to the customer

With Celigo, Therabody's small team went from a blank platform to hundreds of live flows in months. See the platform in action: https://www.celigo.com/request-a-demo/

Celigo Ora is an AI assistant that can do anything the Celigo platform can do — build an integration from scratch, add users, change permissions, read an error at runtime and tell you what went wrong — through plain language. It's now generally available.

Matt Graney, Chief Product Officer at Celigo, walks Nate through what Ora does, how it got built, and learnings from the the beta.

What you'll learn:

▸ What Ora is and what it can reach — account administration, building from scratch, error diagnosis from a pasted screenshot, and runtime troubleshooting, all in one interface

▸ How Ora investigates an error the way a senior admin would: read the message, search for it, read the API documentation, check the audit history to see if someone changed the flow last week

▸ Why an assistant that maps your whole account up front makes impact analysis cheap instead of expensive

▸ The control model — same access as the user, explicit approval before any change, attribution in the audit log, and rollback through version control and integration lifecycle management

▸ How IT scopes the connections it hands to line-of-business builders, so read-only stays read-only whether a human or Ora is driving

▸ Why the maintenance phase, not the build, is where integration TCO accumulates — and what the beta data proved about where AI earns its keep

▸ What Celigo learned running an open beta with no customer restrictions, including turning a thumbs-down into an automated engineering test case the next release has to pass

▸ The unplanned unlock of an LLM-powered interface — users prompting Ora in Japanese and Turkish in a product with no localized UI

▸ Where headless tooling (CLI, platform MCP server) wins versus a chat-driven UI, and why net-new builds and last-mile refinement may end up split between them

▸ What's next: invoking Ora from a link with a pre-filled prompt, scheduled prompts, and Ora building your MCP tools and agent prompts

If you can describe it, Ora can do it — inside the permissions you already have. Now generally available.

Every enterprise has an AI mandate. But how do you build trust and transparency into AI tools and platforms?

Susanne, Celigo's Head of User Experience, has spent the last several months on that problem. When Celigo tested an early Agent Builder prototype that took action without showing its reasoning, it didn't feel powerful to anyone. Developers and business users alike came away anxious. That finding reshaped how every agent interface at Celigo gets built.

In this episode, Susanne names the principles behind that work and explains where each one came from.

The six principles she covers:

▸ Everyone gets supported. The same platform has to work for a developer who wants full control, a mid-tier builder who wants a framework, and a non-technical user watching an error queue.

▸ Trust is built, not granted.

▸ The user stays in the driver's seat.

▸ Transparency is a foundation, not a nice-to-have.

▸ Consistency is a trust mechanism.

▸ Strong design makes complexity invisible.

Susanne and Nate get into how these principles inform the design choices in the Celigo platform, and how AI is transforming user experience as a whole.

See the platform in action: https://www.celigo.com/request-a-demo/

What is EDI — and which delivery model is right for your business? Our hosts break down legacy vs. modern EDI, chargebacks, and how EDI connects to your ERP.

EDI compliance is mandatory for most enterprise trading partners — and getting it wrong is expensive. One supplier in this episode racked up $400,000 in chargebacks from a single trading partner over late ASNs.

In this episode Jeremy and Nate cover what EDI actually is, why every trading partner runs a different version of the same "standard," how VAN, AS2, and SFTP differ in practice, and the real line between legacy EDI and modern EDI.

They also get into where EDI meets API, why APIs won't replace EDI at supply chain scale, and where AI genuinely helps an EDI program versus where it doesn't belong.

What you'll learn:

• What EDI is in plain language, and why it still matters in 2026
• The three flavors of legacy EDI: custom builds, standalone translators, and managed service
• Managed EDI vs. modern EDI: the factors that should actually drive the decision
• EDI vs. API: why they coexist instead of compete
• Where AI fits in EDI configuration and monitoring — and where it's a bad idea
• How to get started without building from scratch or losing control

👉 Get a demo: https://www.celigo.com/request-a-demo/

The command line is having a comeback. AI code editors like Claude Code, Codex, and Cursor have made CLIs s natural place to take action—and Celigo just launched a CLI built for this exact shift.

Learn what a CLI is, why it matters again, and how enterprise developers are using AI-driven CLIs to build production integrations.

A Command Line Interface (CLI) lets developers run text-based commands against an underlying system. For decades, it was a tool for sysadmins and scripters. In 2026, AI code editors changed the pattern — developers describe what they want in natural language, AI interprets the request, and the CLI runs the commands.

In this guide, Celigo walks through what a CLI is, why it's relevant again, the difference between CLI and Platform MCP for AI agents, and what "headless operations" actually means when you're driving enterprise integration work from inside your editor.

What you'll learn:

• What a Command Line Interface (CLI) is and how it works
• Why CLIs are making a comeback in the AI code editor era
• How AI agents use CLIs to take action from natural language requests
• The difference between CLI and Platform MCP for AI agents
• What "headless operations" means for enterprise developers

👉 Book a demo: https://www.celigo.com/request-a-demo/

📚 Related reading: https://www.celigo.com/blog/what-is-an-integration-cli/

🔔 Subscribe for more on agentic AI, MCP, CLI, intelligent automation, and iPaaS strategy for enterprise teams.

Celigo's technical product marketing team used Celigo's intelligent automation platform to reduce their Wordpress publishing time by over 99%—saving nearly 1,000 hours a year.

Nate walks through how his team automated connector page publishing across four systems: Jira, Asana, Google Drive, and WordPress. The result: a publishing cycle that took 60 hours now takes 30 minutes. He also covers how they embedded AI agents into the workflow — with MCP server access to Celigo's competitive intelligence — so the output is grounded in real product positioning, not generic model output.

What you'll learn:

• How Celigo's marketing team reduced publishing cycle time by over 99%
• Live walkthrough of a Jira → Asana → Google Drive → WordPress automation
• Why the team used a WXR file as a WordPress intermediary (and how security governance shaped the architecture)
• What questions any team should ask before automating a cross-departmental workflow

👉 Book a demo: https://www.celigo.com/request-a-demo/

📚 Related reading: https://www.celigo.com/builders-hub/s...

🔔 Subscribe for more on AI agents, MCP, integration automation, and iPaaS strategy for enterprise teams.

Model Context Protocol (MCP) is reshaping how AI agents connect to enterprise systems. Learn what MCP is, how it works, and what production-grade MCP actually looks like at enterprise scale.

The Model Context Protocol solves the integration problem for AI agents — giving them a standardized way to access tools, data, and business systems. In this guide, Celigo walks through what MCP is, how the architecture works, and what enterprise teams need beyond the basics: real-world AI integration applications, governance and audit at scale, and how to connect AI agents to multiple enterprise systems through one MCP server. Anchored in Celigo's MCP Server (GA) and the same 1,000+ maintained connector ecosystem that powers Celigo's iPaaS.

What you'll learn:

• What the Model Context Protocol (MCP) is and how it works
• The architecture of MCP — hosts, clients, and servers
• How AI agents use MCP to connect to multiple enterprise systems
• What an enterprise-grade MCP server actually requires
• When to use MCP — and when traditional API integration is the better fit

👉 Book a demo: https://www.celigo.com/request-a-demo/

📚 Related reading: https://www.celigo.com/blog/what-is-an-mcp-server/

🔔 Subscribe for more on agentic AI, MCP, intelligent automation, and iPaaS strategy for enterprise teams.