By: Roy Pereira, CEO at Unified

As co-founder and CEO at Unified, the Unified API development platform for B2B customer-facing integrations, I've been singularly obsessive, since our company launched earlier this year, about expanding our pre-built integrations suite as fast as possible.

I'm proud to share that our team has successfully built 100 integrations to our Unified API spanning HR, ATS, CRM, Marketing, Ticketing, Enrichment, and Call Center categories in under six months. To add perspective, it typically takes a development team several months to build a single integration.

And when I say we've built this many integrations, I mean it. Each of the 100 integrations (Workday, BambooHR, Greenhouse, etc.) is live, in production, and can be added to our customers' applications today.

Here's what one of our customers had to say:

"Unified is impressively fast at responding to our integration requests and adding them within days. Humi is on a mission to become the ultimate streamlined HRIS platform for Canadians, and we are confident that offering integrations via Unified's ATS API will bring tremendous value to our customers."
— Kevin Kliman, CEO at Humi

One of the questions that I am asked most often is how exactly Unified has become this nimble at transforming a months-long and intensive integration process into an afternoon project.

The proficiency of our team stems from two pivotal elements: 20 years of integration-building experience and our rock-solid architecture.

To truly solve the problem of customer-facing integrations, we rely on an architecture that allows us to build robust and reliable integrations. Our expertise helps us bypass some of the mistakes that inexperienced developers make, like hastily building an architecture that cannot scale as customer requests for more integrations start piling in (and they always do). We've also leveraged internal automation tools that generate code.

Today, in honor of reaching our 100-integrations milestone, I'll walk you through some strategic approaches and critical decisions Unified made to get here.

Decision 1: Modern Architecture

We've built our architecture with high levels of abstraction. Anything that we can abstract, we abstract (e.g., webhooks, authorization scopes, and data models). This approach ensures we can minimize the amount of code required to write for each integration and significantly reduces the surface area of where things can go wrong.

Built upon decades of experience, our approach centers on the concept of "schema-first". Whenever we create a new category or object, our process begins with the data model as the foundation, and we expand from there. This method allows us to establish a solid structure that underpins all aspects of our systems.

Another key element of our infrastructure is our advanced type system. It plays a crucial role in ensuring that incorrect states are not representable in our code base. This degree of robustness and integrity extends across various components, including our data models, core integration architecture, and even our Unified API.

As a result, we can develop and deliver new integrations with speed and reliability.

Decision 2: Unifying > Merging

We always start with designing schemas that work for the majority of our top integrations in any one category. We go deep, but ensure that we never have to adversely modify those schemas to break backward-compatibility.

We also make sure to not include fields that are unique to a small minority of integration vendors or include custom values that link to customer schemas. We do not have to modify our data models as we build new integrations, and developers don't need to do any custom data transformations when they implement new integrations in their applications.

We normalize the format for each field no matter which integration it comes from, so our customers can rely on email fields being emails, date fields being ISO date strings, and addresses being a specific format. And finally, we enrich missing data into objects such as addresses.

Our API is truly unified, which means we never touch the API or our data models when we build a new integration, except when expanding categories (e.g., HRIS or ATS) and the fields that we support (e.g., "title" or "created_at").

We've also considered the entire developer integration workflow by unifying authorization, webhooks, and retry logic. With Unified, developers integrate once to add multiple integrations to their products, while Unified does all the heavy lifting.

Decision 3: Automate

One of the key factors driving the speed and efficiency of our development process is the strategic use of automation alongside our extensive integration expertise. We've developed proprietary tools to rapidly scaffold and generate code for new integrations to facilitate this. Our automation tools allow us to create new integrations within incredibly short timeframes, ranging from days to hours or even minutes.

During a recent product demo with a prospect, we showcased our capabilities by swiftly building and deploying a critical integration request they had. In a matter of minutes, we fulfilled their deal-breaker requirement.

The results speak for themselves. In the current quarter alone, we successfully shipped over 20 integrations within 30 days, demonstrating our commitment to prompt and reliable delivery.

Unified is one API to integrate them all

This winning combination of modern architecture, years of integration expertise, adherence to industry standards, and strategic use of internal automation tools allow us to speed up our integration development and provide our customers with the advantage of quickly incorporating our pre-built integrations into the products.

We're excited to continue to innovate at Unified and solve hard, critical integration-related problems for our customers. If you're curious about Unified's integrations-as-a-service solution, consider signing up for a free account or talk to our team.