Connect existing platforms
This is the most common case: your website needs to send or recieve data from a tool you already use.
We work with official APIs, no-code automation tools (Zapier, Make, n8n), or platform-specific connectors.
Your site, plugged into the tools you already use
We connect your website to the platforms that run the rest of your business. CRMs, payment processors, booking systems, email tools, analytics platforms, and the custom APIs that don't have an off-the-shelf option.
The right fit
When integration work is the right move
Most websites talk to other software. When that conversation breaks, or never quite started, integration work is what fixes it. Common triggers we hear:
An integration that worked fine for two years suddenly stops, usually after a third-party platform update
A new tool the team wants to use doesn't have a native plugin for your platform
Data lives in three systems and your team is copy-pasting between them
A custom workflow that no off-the-shelf automation tool can quite handle
The fix can be small (a Zapier scenario), medium (a Make.com flow with a few branches), or large (a custom Rails service that talks to several APIs). We pick the size that fits the problem.
Two approaches
Two flavors of integration work
Build custom APIs
When no off-the-shelf option does what you need, we build a custom service. Usually Ruby on Rails, sometimes a serverless function.
This comes up more often than you'd expect: sometimes the platform has an API but no documentation, sometimes the data transformation logic is complex enough that a visual automation tool can't handle it cleanly, and sometimes we're connecting systems that were never designed to talk to each other.
When the API work is part of a larger system, it often pairs with Application Building.
What we've worked with
Platforms and tools we've worked with
Not exhaustive; if your stack isn't here that doesn't mean we can't work with it.
A free consultation is the best way for us to let you know what we can and can't do.
E-commerce & fulfillment
CRM & marketing
Payments & billing
Analytics & tag management
Booking, scheduling, & forms
Communication & support
Documents & workflow
Custom
Direct REST and GraphQL APIs
Webhooks
OAuth flows
Custom Rails services
How we work
How it usually works
Integrations land in three shapes, depending on the relationship.
Inside an active retainer. Most integration work happens here. We pick it up alongside your other work, ship it on a regular sprint, and maintain it as part of the retainer. If something breaks because a third-party platform made a change, we fix it. See Maintenance for how that works.
As a standalone project. For clients without a retainer, we scope an integration as a discrete project. Usually a few days to a few weeks of work, depending on scope. Maintenance after handoff requires a maintenance retainer.
As part of a larger build. When integration work is bundled with Application Building or a website refresh, it's tracked inside that engagement.
Starting points
What to expect on cost
Integration work is priced around what needs to be built and transmitted. Each request body that needs to be constructed, each response that needs to be parsed and handled, the complexity of the authorization flow, and whether we need to negotiate API access with a third-party team or vendor are all factors. Here are starting points by complexity. Final pricing follows a scoping conversation.
Simple
Single-direction data push or pull, one platform, standard OAuth or API key auth
Starting at $1,500
Complex
Multiple endpoints, bidirectional sync, custom auth flows, webhook handling, conditional logic
Starting at $4,500
Enterprise
Multiple systems, vendor negotiation required, regulated data (HIPAA, PCI), or integration into enterprise platforms with non-standard APIs
Custom
Ongoing maintenance after a standalone integration requires a maintenance retainer. We're upfront about this before the work starts.
Common questions
Honest answers to the questions we get most
- How do you make sure an integration doesn't corrupt or lose our data?
-
We work against copies of your data (not the live version) until the integration is tested and we're confident in its behavior. We write unit tests for the transformation logic, which is the part that maps data from one system's shape to another's, so problems show up in a test run before they reach production. We also instrument every integration with logging that's readable without a developer: when something goes wrong, the logs tell you what was sent, what came back, and where it failed.
- How long does an integration actually take?
-
Longer than most people expect. A simple one-direction sync between two platforms with a standard API can take a few days. Anything with custom auth, conditional logic, bidirectional sync, or a platform that requires generating keys through an admin account can stretch to a few weeks. We scope carefully before we start, so you know what you're in for.
- Do you maintain the integrations you build?
-
Yes, with a maintenance retainer. For standalone projects, maintenance is not included at handoff, and we're clear about that before the work starts. If you want coverage, we'll set up a retainer. See Maintenance for what that looks like.
- What do you need from us to get started?
-
Usually, admin-level access. That surprises people, but most platforms require admin permissions to generate API keys, configure OAuth credentials, or set up webhook endpoints. We'll walk you through exactly what we need and why before we ask for access to anything.
- What if my platform doesn't have an integration for the tool I need?
-
That's exactly when we build one. If the platform has an API (even an undocumented one), we can usually work with it. If it doesn't, we look at export options, webhooks, or other data pathways. We'll tell you in the scoping conversation what's realistic.
- What if the integration breaks because the third-party platform changed something?
-
This happens regularly. Inside a retainer, we fix it as part of normal work. For standalone integrations with a maintenance retainer, we fix it and document what changed. For one-time projects without a retainer, we'll let you know what happened and quote a fix. See Maintenance for how ongoing coverage works.
- Can you fix an integration someone else built?
-
Usually, yes. We'll need read access to whatever's there, and some time to understand how it was put together. Most integrations aren't complicated once you can see the shape of them.
In practice
Integrations in the wild
Featured case study: Rosie's House
Rosie's House is a Phoenix youth music academy that runs free lessons for kids who wouldn't otherwise have access. When their mix of spreadsheets, paper forms, and disconnected tools stopped scaling, they needed help choosing and adopting a student information system, not building one from scratch.
We ran a structured evaluation, recommended DreamClass (built specifically for music schools), and then did the integration work that made the recommendation actually useful: a Make.com flow that pushes enrollment and attendance data into Salesforce for donor and grant reporting, automatically.
The integration is opinionated by design. It only moves the fields their reporting workflow needs, so the Salesforce side stays clean and auditable, and maintaining it doesn't require a developer.
Let's connect the dots
Got a tool that needs to talk to your site?
A free consultation is the fastest way to scope it. We'll look at your stack, your goals, and the gap, and tell you whether the answer is a Make.com scenario, a custom build, or something in between. We've run integrations for eCommerce stores, healthcare practices, nonprofits, and community-based organizations.