Comparisons
Unified API vs custom integrations: breadth or depth?
A unified API lets you connect to dozens of HRIS, CRM or accounting systems through one schema. Custom integrations connect to one system at a time, but use everything that system offers. Here is where each approach wins.
Use a unified API when you need basic coverage across many systems quickly and its common data model is enough. Use custom integrations when enterprise customers need custom fields, write-back, tenant-specific logic or systems the unified API doesn’t cover in depth. Many teams start with a unified API and add custom integrations for their largest customers.
What is a unified API?
A unified API maps many systems in one category to a single common schema. You integrate once, and the provider handles each underlying system.
- One schema per category For example, one “employee” object that maps to many HRIS products.
- Provider-managed connectors The provider maintains authentication and API changes for each system.
- Examples of the category Merge, which covers several categories including HRIS, ATS, CRM and accounting, and Finch, which focuses on HRIS and payroll, are well-known providers.
How do unified APIs and custom integrations compare?
Costs are relative and depend on provider pricing, customer count and the systems involved.
| Criteria | Unified API | Custom integration |
|---|---|---|
| Speed to first integration | Fast: one integration covers many systems | 2–5 weeks per system |
| Cost at 1 integration | Low to medium: subscription plus build | Medium: one build project |
| Cost at 10 integrations | Low to medium: same code, more systems | Medium: shared components reduce each build |
| Cost at 50 integrations | Depends on per-connection or per-customer pricing | Medium to low per integration |
| Custom logic | Limited to the common model, plus provider passthrough options | Unlimited |
| Maintenance burden | Provider maintains connectors | Yours or your partner’s |
| Control and ownership | Provider owns the mapping layer | Full ownership |
| Vendor lock-in | High: your code depends on the provider’s schema | Low |
| Data residency | Depends on the provider | Any region you host in |
Where do unified APIs work well?
A unified API is a strong choice in these situations.
- Long list of systems, shallow needs You need employees and departments from 30 HRIS products, and basic fields are enough.
- Read-heavy use cases You mostly pull data into your product rather than writing back.
- Early-stage products You need coverage to close deals now and can go deeper later.
- Small integration team Maintaining many connectors yourself isn’t realistic.
Have an integration request in your backlog?
Send it over. You get a written scope and a fixed quote within 2–3 days.
Where do unified APIs fall short?
The common schema that makes a unified API fast also limits what it can do.
- Custom fields Enterprise customers rely on fields that don’t exist in the common model, and passthrough options vary by provider.
- Write-back Writing data back to the source system is supported unevenly across systems and objects.
- Tenant-specific logic Effective dating, rehires, multi-entity setups and custom approval rules rarely fit a common model.
- Coverage depth A system may be “supported” for some objects but not the ones your customer needs.
- Data flow and residency Data passes through the provider, which may matter for security reviews.
These gaps show up most with enterprise HRIS such as UKG, where each tenant can be configured very differently.
When is a custom integration the right choice?
Go custom when depth matters more than breadth.
- Your largest customers need it One enterprise deal justifies a dedicated, deep integration.
- You need two-way sync Your product writes back to the HRIS, LMS or CRM.
- The system is unusual A legacy, on-premise or niche system that unified APIs don’t cover.
- Security review requires it The customer won’t approve another third party in the data flow.
- You need predictable cost per customer A direct integration costs the same whether one customer or fifty use it, which matters when you price your own product per seat or per account.
For example, LearnUpon’s enterprise customers often need provisioning from their HR system with custom groups and enrolment rules. See the LearnUpon case study.
How do teams combine the two?
- Start with a unified API for coverage Answer “do you integrate with X?” for most prospects.
- Add custom integrations for depth Build direct integrations for the systems and customers that need more.
- Keep a consistent internal model Map both sources into the same internal objects so your product doesn’t care where data came from.
What does this look like for an HRIS integration?
Say your product needs employee data from customers’ HR systems to provision users and assign training.
- Through a unified API You integrate once and support many HRIS products. Names, emails, departments and managers come through the common model. That covers most mid-market customers well.
- Where it gets harder An enterprise customer on UKG needs cost centres from a custom field, future-dated hires handled correctly, and training completions written back. Each of these may fall outside the common model.
- Through a direct integration You use UKG’s own APIs and file exports, handle effective dating explicitly, and write completions back where the tenant allows it.
- In combination The unified API serves the long tail of HR systems. Direct integrations serve the enterprise customers whose deals depend on depth.
See the HRIS integration guide for how to plan the field mapping and the data flows for each approach.
What mistakes do teams make with unified APIs?
- Trusting the coverage list “Supported” can mean some objects and fields, not the ones your customer needs.
- Building product features on the common model only When an enterprise customer needs more, the feature has to be redesigned.
- Forgetting the security review Another processor in the data flow can add weeks to an enterprise deal.
- Ignoring per-customer pricing Costs that scale with each connected customer change the economics as you grow.
Decision checklist
- Which objects and fields does your largest customer actually need?
- Do you need to write data back, or only read it?
- Does the unified API cover those systems in depth, not just by name?
- How will pricing change as customers connect more systems?
- Will customers’ security teams accept the provider in the data flow?
- How would you migrate away if you needed to?
Where does Hypogen fit?
Hypogen builds direct, custom integrations where a unified API stops: custom fields, write-back and tenant-specific logic. We can also work alongside your existing unified API. See the partnership model, custom integration vs iPaaS and our BambooHR integration page.
FAQ
Frequently asked questions
Can't find your question? An integration engineer will answer it.
Last updated
Is a unified API the same as an iPaaS?
No. A unified API gives you one API for many systems in a category. An iPaaS gives you workflows and connectors to build integrations between systems.
Can a unified API handle custom fields?
Some providers offer passthrough or custom field support, but coverage varies by provider and system. Check against your customers’ actual fields.
Do unified APIs support write-back?
For some systems and objects. Check each system and object you need, not just the provider’s overall list.
When should we switch to direct integrations?
When your largest customers need depth the unified API can’t provide, or when per-customer pricing outgrows the cost of building direct.
Can we use both at once?
Yes. Many teams use a unified API for breadth and direct integrations for the systems that matter most.
How long does a direct HRIS integration take?
Typically 2–5 weeks from signed scope, with API access from the customer usually the longest step.
Need more than your unified API provides?
Tell us which fields or systems are missing, and we'll scope the direct integration.