Ampersand vs HotGlue | Product Integrations vs Embedded ETL
See more here
Integration Infrastructure Comparison

Ampersand vs HotGlue: Product Integrations vs Embedded ETL

Ampersand is the native integration infrastructure for AI agents: real-time, bi-directional product integrations with direct API access. HotGlue is embedded ETL — it ingests your customers' SaaS and file data into your database or warehouse. Here's how to tell which one your team actually needs.

See the Full Comparison ↓ Read the Docs

TL;DR — The Key Differences

  • Ampersand is the native integration infrastructure for AI agents. Agent-ready, real-time direct integrations with sub-second webhooks, bi-directional sync, and full custom object support. HotGlue's one-way Singer-based pipelines can't support the real-time, read-write patterns AI agents need.
  • Ampersand is a product integration platform. Bi-directional reads and writes, real-time webhooks, per-customer field mapping, embeddable UI, custom object support. The integration lives inside your application and interacts with your customer's systems in both directions.
  • Ampersand delivers sub-second webhooks via event-driven architecture. HotGlue is batch ETL on scheduled intervals — appropriate for data ingestion, too slow for real-time product UX.
  • Ampersand powers native, bi-directional product integrations. HotGlue is embedded ETL for customer data ingestion — it pulls data from your customers' SaaS apps into your storage layer. That's a useful job, but it's not the same as a customer-facing integration with real-time reads, writes, and field mapping.
  • Ampersand is bi-directional by default. HotGlue is fundamentally one-way: source SaaS → your storage. There's no first-class write-back path into your customer's CRM or ERP. If your product needs to create records or push updates into the customer's system of record, HotGlue isn't the tool.
  • Ampersand is the choice if your product use case is "we need to read and write in our customer's systems in real time." HotGlue is a credible choice if your product use case is "we need to read our customer's data to train a model or generate a report."

Feature-by-Feature Comparison

How the two platforms stack up across the dimensions that matter most for product integrations.

Dimension Ampersand HotGlue
Category Product integration platform Bi-directional Embedded ETL — data ingestion One-way
Primary Use Case Customer-facing reads + writes inside your app Ingesting customer data into your storage/warehouse
Sync Direction Bi-directional with conflict resolution Reads + writes One-way: source → your DB Read only
Data Freshness Sub-second webhooks (event-driven) Real-time Scheduled ETL jobs (minutes to hours) Batch
Writes / Actions First-class write actions into customer systems Not a first-class capability Read-focused
Custom Objects Full native support, all tiers Supported for ingestion; no write-back
Per-Customer Field Mapping Built-in with embeddable UI Included Target schema mapping, not per-customer config UI
Embeddable UI White-labeled React components for auth, field mapping, sync settings Auth widget; no first-class config UI for customers
Credential Ownership You own & export OAuth tokens Vendor stores credentials
Configuration Declarative YAML in Git + CI/CD Tap/target configs managed via HotGlue dashboard
AI / Agent Support Open-source AI SDK + MCP server Agentic-ready No native agent tooling
Open Source 250+ connectors as Go libraries on GitHub Inspect + extend Singer taps under the hood (open ecosystem)
Compliance SOC 2 Type II, GDPR, ISO 27001 SOC 2 Type II, GDPR, HIPAA
Pricing Entry Free tier → $999/mo (usage-based) Per-tenant / per-connector, sales-quoted

Where Ampersand Wins

The advantages that matter when your integration powers in-product UX, not offline data analysis.

⇄

True Bi-Directional Sync

Ampersand reads from and writes to your customer's systems. Create tasks in their CRM, update opportunities, post notes, attach files — all from inside your product. HotGlue is built to ingest data out of customer systems into your storage layer; write-back isn't the model.

⚡

Sub-Second Real-Time Sync

Ampersand's event-driven architecture delivers webhook notifications in under one second. 11x cut their AI phone agent's CRM response time from 60 seconds to 5. HotGlue is scheduled batch ETL — the right model for loading a daily dataset, the wrong model for real-time UX.

🎨

Embeddable Customer UI

Ampersand ships white-labeled React components for auth, field mapping, and sync settings. Your customer configures their own integration inside your product, no custom UI work required. HotGlue's embedded widget is primarily for authorization, not customer self-serve configuration.

🧩

Full Custom Object Support

Ampersand supports reading and writing any object or field, standard or custom, on every tier. Custom objects are where enterprise deals actually live. HotGlue can ingest custom objects, but there's no bi-directional path back into those objects for product actions.

🗃

Integrations As Code

Ampersand integrations are defined in amp.yaml files that live in your repo, go through PR review, and ship with your CI/CD. HotGlue's tap/target configuration lives in a separate dashboard — a second source of truth your engineering team maintains outside of Git.

🤖

Built for AI Agents

Ampersand's open-source AI SDK exposes integrations as tools that LLMs can invoke. The Docs MCP lets Claude Code and Cursor spin up integrations in minutes. HotGlue has no native agent tooling — it's a data pipeline, not an action layer.

Pricing at Scale

The platforms measure different things and solve different problems — here's the side by side.

Ampersand

$999 /month
  • ✓ Free tier available
  • ✓ Transparent usage-based credits
  • ✓ Bi-directional reads + writes
  • ✓ Sub-second webhooks included
  • ✓ Custom objects included on all tiers
  • ✓ Embeddable React UI out of the box
  • ✓ Credential ownership & export
  • ✓ SOC 2 Type II, GDPR, ISO 27001

HotGlue

Contact sales
  • ⚠ Per-tenant / per-connector pricing
  • ⚠ Sales-quoted, no public pricing
  • ✗ One-way ETL, no write-back
  • ✗ Batch ETL, not real-time
  • ✗ No first-class field mapping UI for end customers
  • ✗ Vendor holds OAuth tokens
  • ✗ No native AI agent tooling
  • ✓ SOC 2 Type II, GDPR, HIPAA

What Customers Say

"Using Ampersand, we cut Julian's response time from 60 seconds to 5."
Muizz Matemilola, Engineering — 11x
"We chose Ampersand because we want to build an integration that we don't need to rebuild, and we want to meaningfully accelerate our upmarket journey."
Kshitij Grover, CTO — Orb
"Ampersand is the first developer platform that gets it right."
Eric Engoron, Engineering — Clay
"Ampersand is core to how we grow."
John Peña, CTO — Hatch (acq. by Yelp)
"Ampersand is helping Square connect to more upmarket Sellers, driving strong revenue growth."
Max Friz, Partnerships Lead — Square

When to Choose Each Platform

We believe in being honest. These tools solve different problems — most teams will eventually want both.

Choose Ampersand When You Need…

  • ✓ Bi-directional reads and writes into customer CRM/ERP
  • ✓ Real-time, sub-second data for AI agents or voice products
  • ✓ Per-customer OAuth, field mappings, and embeddable UI
  • ✓ Custom objects and fields on every tier
  • ✓ An integration that drives in-product UX, not offline analysis
  • ✓ Integrations versioned in Git and shipped with your code
  • ✓ Credential ownership and zero vendor lock-in

Choose HotGlue When You Need…

  • ✓ To ingest your customers' SaaS and file data into your database
  • ✓ Batch ETL pipelines feeding analytics, reports, or ML training
  • ✓ Read-only access to many data sources in a normalized target schema
  • ✓ A Singer/tap-based architecture with familiar tooling
  • ✓ A data-team-owned ingestion layer for your product

Need More Than Data Ingestion?

If your product has to write back into customer systems — update records, create tasks, push notes — you need a bi-directional product integration platform. That's Ampersand.

Speak with an Engineer →

Frequently Asked Questions

Yes — specifically for SaaS products that need to ingest their customers' data. HotGlue is an embedded ETL layer: it pulls data from customer SaaS, files, and databases and lands it in your storage so your product can analyze it. That's a real and useful use case. But if your product also needs to write back into those customer systems (create tasks, update records, push notes), HotGlue isn't designed for that. Ampersand is.
Yes, they're complementary. Some teams use a data-ingestion layer for analytics pipelines and a product-integration platform for bi-directional in-product UX. The two serve different use cases owned by different teams (data engineering vs product engineering).
Ampersand's event-driven architecture delivers webhook notifications in under one second. That's the difference between an AI voice agent that feels real-time and one that pauses awkwardly while a batch job waits to run. HotGlue is batch ETL by design — the right model for ingestion, the wrong model for real-time product UX.
Yes — on every tier. You can read and write custom objects and custom fields in Salesforce, HubSpot, NetSuite, Dynamics, and more without workarounds. Ampersand treats custom objects as first-class, not a passthrough afterthought.
Yes. Ampersand's open-source AI SDK exposes integrations as tools LLMs can invoke. The Docs MCP lets AI coding agents generate integration configs in minutes. Declarative YAML is machine-readable and machine-writable.