If you're a product or partnerships leader at a B2B SaaS company, integration requests are probably one of the loudest things on your roadmap right now. The question isn't whether to offer them, it's how to do it without your engineering team owning connector maintenance forever. This post covers what an embedded integration platform actually is and whether it fits what you're building.
TLDR:
- Embedded iPaaS sits inside your product so end users connect their own tools directly from your UI, no internal IT team required
- In-house integrations work fine for one or two connectors, but the maintenance cost compounds fast as your catalog grows
- hotglue prices on active tenants (not data volume), starting at $1,500-$2,500/month base plus $20-$100 per active tenant
- Most embedded iPaaS tools skip on-premise systems like QuickBooks Desktop and Sage 300 CRE; hotglue connects both
- hotglue gives B2B SaaS teams 650+ open-source connectors with Python transformation scripts and full Git integration
What Is Hotglue? (Not the Craft Supply)
Hotglue is an embedded iPaaS built for B2B SaaS product teams who need to ship customer-facing integrations without drowning their engineering team in maintenance. The craft supply stays in the junk drawer.
The Problem Every B2B SaaS Product Team Faces
Your customers don't care that QuickBooks changed its API schema last quarter. They just know their data stopped syncing, and they're filing a support ticket.
Every B2B SaaS product team hits this wall. One integration request becomes ten. Ten becomes a backlog. Each connector you build in-house carries a hidden maintenance tax: API endpoint changes, schema drift, auth token expiration, connector rebuilds every time a third-party pushes an update. It compounds quietly until integrations are consuming a third of your engineering sprints.
The iPaaS market is projected to reach $55.5 billion by 2033, a signal of just how widespread this problem has become. Building integrations looks like a one-time project. It never is.
What Is an Embedded Integration Platform?
An embedded integration platform sits inside your product. End users connect their own tools, whether that's QuickBooks, Salesforce, or Shopify, directly from within your application's UI. The SaaS vendor doesn't build every pipeline from scratch; the embedded layer handles authentication, orchestration, and data movement on their behalf.
That's a meaningfully different category from two things it often gets confused with.
Traditional iPaaS tools like Workato or MuleSoft are built for internal IT teams automating workflows between internal systems. Your customers never touch them. Unified API abstractions like Merge take a different approach: they standardize schema across connectors so you write one API call instead of many. Convenient, but you trade away connector-level control and visibility into what's actually happening under the hood.
Embedded iPaaS sits in between: purpose-built for customer-facing integration workflows, with the connector depth and configurability that unified APIs abstract away. Your end users connect their tools. Your team controls how data moves.
How Hotglue Works
Getting a live integration running with hotglue follows a straightforward path:
- Embed the hotglue widget inside your product, or send end users a Magic Link if you'd rather skip the embed entirely
- Your customer authenticates their tool (QuickBooks, Salesforce, Shopify, whatever they use) directly from your UI
- hotglue creates a tenant record for that connected end user
- A flow defines how data moves: which connector, which entities, in which direction
- Transformation scripts in Python shape the data before it lands in your backend
- Syncs run on a cron schedule you configure, or on demand via API
Each tenant's credentials and data stay isolated. Your engineering team writes transformation logic once, and hotglue handles scheduling, retries, and API rate limiting from there. (Yes, that includes the 2am rate-limit errors. You're welcome.)
The Connector Library: What You Can Connect
Hotglue ships with 650+ open-source connectors spanning the tools your customers actually use day to day, organized across five major categories:
- Accounting and ERP: QuickBooks Online, QuickBooks Desktop, NetSuite, Sage 100, Sage 300 CRE, Microsoft Dynamics 365, Acumatica
- CRM and sales: Salesforce, HubSpot
- Payroll and HR: Paylocity, ADP, Workday, Gusto
- E-commerce and marketplaces: Shopify, Amazon, TikTok Shop, Faire, Linnworks
- Finance and payments: Stripe, Airwallex, Tipalti
Every connector is open-source, built on the Singer spec or Airbyte YAML. Your engineers can read the code, fork a connector, or build a net-new one from scratch if the catalog doesn't cover what you need. No black boxes.
On-Premise and Legacy System Support
Most embedded iPaaS tools quietly skip on-premise systems. There's no REST API to call, no OAuth flow to wire up. Instead, you're dealing with local database access, Windows agents, and connectors that need to survive software updates without breaking. It's genuinely harder to build, so most vendors don't.
Hotglue does. A few specific examples worth knowing:
- QuickBooks Desktop runs on a Windows agent via the QuickBooks Web Connector, handling multi-user environments that cloud-only tools can't reach
- Sage 300 CRE installs a connector directly on-premise, connecting to the local database and staying resilient when the customer's software updates
- Sage 200, the UK accounting staple, connects via a cloud proxy that bridges the on-premise system without requiring direct database access
If you're selling into construction, nonprofit, or accounting-adjacent verticals, your customers are very likely running one of these systems. On-premise accounting software doesn't go away just because the SaaS world moved on.
Python-Powered Data Transformation
Raw data from a source system rarely arrives in the shape your backend expects. Field names differ. Nested JSON needs flattening. Two sources need joining before anything lands downstream.
Hotglue's transformation layer sits between the connector and your backend, written in Python all the way down. You get a JupyterLab-powered workspace with full access to Pandas and Dask, so complex reshaping, multi-source joins, and nested JSON transformations are just Python code. No proprietary drag-and-drop logic, no vendor-specific query language to learn.
Every ETL script is Git-backed, so you can commit changes, review history, and revert if something goes sideways. Separate dev and production environments mean in-progress changes never touch live syncs.
For teams that want to move faster, GluestickAI generates transformation code from plain-language descriptions. Describe what you need, get working Python back. Customer data is never stored or used to train the model.
Embedded iPaaS vs. Building Integrations In-House
Building in-house gives you full control and zero vendor dependency. For a single, stable integration your team knows deeply, that tradeoff can make sense.
The math changes fast once you're managing several connectors. API endpoints change. Auth flows break. Schema drift creates silent data bugs. Each connector you own is a maintenance commitment that compounds as your catalog grows.
| Scenario | In-house | Embedded iPaaS |
|---|---|---|
| One or two stable integrations | Works fine | Likely overkill |
| Growing customer integration requests | Gets expensive fast | Better fit |
| On-premise or legacy systems | Very hard | Hotglue handles it |
| Engineering team stretched thin | Risky | Frees bandwidth |
In-house wins on control, embedded wins on scale. Most product teams hit the crossover point earlier than they expect, and choosing the best embedded iPaaS solution depends on where you are in that journey.
How Hotglue Prices Its Integrations
Hotglue prices on tenants, not data volume. An active tenant is a connected end customer who has run at least one sync within a rolling 30-day window. If a customer syncs infrequently or skips a month, they don't count toward your bill for that period.
The structure is a base license ($1,500-$2,500/month) plus a per-active-tenant fee, typically $20-$100/month per tenant depending on the connector. One tenant connecting to multiple connectors still counts as one tenant.
That last point matters commercially. With volume-based pricing, a large historical sync or a high-frequency data source can spike your costs unexpectedly. Tenant pricing doesn't do that.
Hotglue also supports several partnership models:
- You pass the integration cost through to your end customer directly.
- You bundle it into your own implementation or setup fee.
- You run a white-label reseller arrangement, billing end customers directly and buying from hotglue wholesale.
Contracts typically start at $25-50k annually and ramp with tenant growth, with the intent for hotglue's cost to stay under 10% of a customer's MRR as your integration catalog scales.
What Hotglue Looks Like in Practice
Two examples help make this concrete.
Tipalti is an AP automation product. Their customers need payees, bills, and approvals syncing bidirectionally between Tipalti and their ERP of choice. Hotglue powers those flows, handling the back-and-forth data movement across accounting systems like NetSuite and Sage without Tipalti's engineering team rebuilding logic for each customer's setup.
Linnworks runs e-commerce operations for multi-channel merchants. When they needed a Faire marketplace integration, the requirement was order, inventory, and fulfillment data moving reliably between Faire and a merchant's existing stack. Hotglue built the connector and owns the sync, so Linnworks ships the integration as a native feature of their product.
The pattern is the same in both cases: a B2B SaaS company has customers who run their business in tools that need to talk to each other, and the SaaS vendor can offer that connection natively without their engineering team owning connector maintenance indefinitely.
Who Hotglue Is Built For
Hotglue fits a specific company profile: B2B SaaS, 50 to 1,000 employees, with recurring integration requests that engineering can't staff fast enough. If you're building internal automation tools for an IT team, this probably isn't your product.
The trigger is almost always the same. One customer asks for a QuickBooks connector. Your engineering team is underwater. That single request becomes the forcing function for a real conversation about how you're going to scale integrations long-term.
The people who feel this pain most acutely are usually in customer success, partnerships, or solutions engineering. They know exactly which integrations are blocking deals or causing churn. The people who make the final call are usually a CTO or engineering lead, and they often start skeptical, instinctively wanting to build in-house.
That skepticism is fair. Hotglue's answer is that engineers get more control than hand-coding connectors, not less: open-source connectors, Python transformation scripts, full Git integration. Hotglue handles maintenance; your team owns the logic.
The primary champions are Heads of Partnerships, CPOs, and VPs of Product. They're the ones who see integrations as a growth lever first and a maintenance problem second.
hotglue at Scale: What the Platform Handles Today
Seventy-plus B2B SaaS companies, 38,000+ active tenants, and roughly 10 billion records processed every week. That's the current operating baseline.
The numbers matter less as benchmarks and more as a signal: the infrastructure holds up at real production volume, across real multi-tenant deployments, without requiring customers to architect around its limits.
A few specifics worth anchoring to:
- New connector from API access to production takes 1 to 2 weeks, giving product teams a predictable build timeline.
- Chargebee RevRec cited roughly a 90% reduction in integration implementation time after adopting hotglue.
- SOC 2 Type II and GDPR compliance are built in by design, not bolted on after the fact.
- The connector model is fully open-source and Singer and Airbyte YAML compatible, with no black-box lock-in.
That open-source connector model is worth pausing on. Most embedded iPaaS vendors ship connectors you can configure but not inspect. With hotglue, your engineers can read the code, fork it, and extend it. If a connector doesn't exist yet, you can build one. If an upstream API changes and you need to patch something before the next scheduled update, you can. That's a different relationship with the tool than most integration vendors offer. For a deeper orientation, the hotglue 101 primer is a good next read.
The short version: hotglue is an embedded integration layer built for B2B SaaS product teams who need customer-facing connectors at scale, without handing their engineering team a permanent maintenance burden. The infrastructure is there. The compliance is there. The connector depth, especially for accounting and on-premise systems, is there. Book a demo to see it in action with your stack.
Final Thoughts on Embedded iPaaS and What Hotglue Brings to It
Integrations rarely stay simple, and the ones your customers care about most are usually the hardest to maintain. Hotglue handles the connector layer so your team can focus on what actually moves your product forward. When the backlog gets loud enough, a demo is a good place to start the conversation.
FAQ
How does an embedded iPaaS work differently from a traditional integration platform like Workato or MuleSoft?
A traditional iPaaS is built for internal IT teams wiring together internal systems; your customers never touch it. An embedded iPaaS sits inside your product, so end users connect their own tools (QuickBooks, Salesforce, Shopify) directly from your UI, while the platform handles authentication, data movement, and scheduling on your behalf. The key difference is who the integration serves: internal workflows vs. customer-facing connectivity at scale.
Embedded iPaaS vs. building integrations in-house: what should a B2B SaaS product team actually choose?
Building in-house works for one or two stable integrations your team knows deeply. The math changes once you're managing several connectors simultaneously: API endpoints change, auth flows break, and schema drift creates silent data bugs that compound over time into a permanent engineering maintenance burden. Most product teams hit that crossover point earlier than expected, and that's where an embedded iPaaS like Hotglue pays for itself.
How do I add customer-facing integrations like QuickBooks or Salesforce to my SaaS product without building each connector from scratch?
Hotglue gives you 650+ open-source connectors out of the box. Embed the widget (or send a Magic Link), your customer authenticates their tool, and Hotglue handles scheduling, retries, and API rate limiting from there. Your engineering team writes transformation logic in Python once; Hotglue owns connector maintenance, API endpoint updates, and multi-tenant data isolation going forward.
What does Hotglue's pricing look like as our active customer base grows?
Hotglue prices on active tenants, not data volume. An active tenant is a connected end customer who ran at least one sync in a rolling 30-day window. The structure is a base license ($1,500-$2,500/month) plus a per-tenant fee ($20-$100/month depending on the connector), with contracts typically starting at $25-50k annually and designed to stay under 10% of your MRR as your integration catalog scales. One tenant connecting to multiple connectors still counts as one tenant.
What is the best embedded integration platform for B2B SaaS products that sell into accounting or on-premise software verticals?
Hotglue is one of the few embedded iPaaS options that actively supports on-premise systems: QuickBooks Desktop via a Windows agent, Sage 300 CRE via a direct on-premise database connector, and Sage 200 via a cloud proxy. Most embedded iPaaS vendors skip these entirely because they're genuinely harder to build. If your customers run legacy accounting software in construction, nonprofit, or finance verticals, that connector depth is the differentiator worth checking first.