How Sequence built 20+ integration scenarios in 2 weeks with Membrane

Goals

• Build integration infrastructure that enables real-time data access across accounting and CRM systems
• Support complex billing workflows that require both unified logic and per-customer customization
• Maintain flexibility for custom fields, edge cases, and app-specific configurations

Highlights

• Built production integration infrastructure in 2 weeks supporting real-time billing operations
• 20+ integration scenarios live with unified logic that customizes per app and per customer
• Real-time data access across accounting and CRM systems powering seamless customer onboarding
• Custom field mappings at scale: Define schemas once, apply across all apps with app-specific configurations

Company Overview

Founded: 2022
Industry: Billing/Fintech
Number of employees: 40
Location: London, UK

Website: https://www.sequencehq.com/

Sequence is a platform for streamlining pricing, billing, and invoicing workflows for fast-growing B2B SaaS companies. Backed by leading VCs including a16z, Firstminute Capital, and Salesforce Ventures, Sequence eliminates the slowdown caused by custom pricing and ensures smooth revenue operations.

The platform allows users to translate commercial terms from quotes or contracts into automated billing schedules – including discounts, minimums, and credit grants – while providing a product catalog that establishes a single source of truth for products and pricing.

Sequence is used today by established fintech and SaaS companies like Duffel, Ravelin, Primer, and Humanloop, and is on the path to becoming the leader for scaling pricing, billing, and invoicing workflows.

For Sequence, integrations are mission-critical. They sit firmly within an ecosystem of payments, billing, and invoicing apps. Being able to access data from accounting systems (Xero, QuickBooks) and CRMs (Salesforce, HubSpot) is crucial for customer onboarding and a great user experience.

The Challenge: Building integration infrastructure for real-time billing operations

Sequence sits at the center of a complex ecosystem. Their platform needs to pull data from CRMs to understand deal structures, sync with accounting systems to manage invoices in real time, and handle billing operations that require immediate updates across multiple systems.

Sequence’s Head of Engineering knew they needed infrastructure that could handle both consistency and flexibility:

• Unified core logic: Build once, apply across all apps – but without forcing lowest-common-denominator abstractions
• Real-time operations: No sync delays or batch processing – billing operations happen immediately
• Flexible customization: Custom fields, edge cases, and per-customer configurations without complexity
• Production-grade reliability: Handle billing operations at scale with confidence

“We thought about building this in-house, but quickly recognized that our expertise would be limited to apps we knew well – Xero, QuickBooks. What about the dozens of other apps our customers use?”

Sequence needed infrastructure that could handle the complexity of real-time billing integrations across an entire ecosystem. They were initially attracted by the idea of unified APIs like Merge.dev or Codat, which promised to enable integrations with a single API and single piece of development work. However, they quickly ran into roadblocks when they attempted to scale their integrations for Accounting & CRM tools:

The limitations of unified APIs:

• Sync delays killed real-time operations: Unified APIs operate on scheduled syncs, creating lags that broke customer onboarding flows and invoice operations.
• Abstraction leaked everywhere: Fields that worked for Salesforce didn’t exist in HubSpot. The “unified” model wasn’t actually unified – it required constant workarounds and custom logic.
• Complexity compounded instead of simplified: As they tried to support more apps and edge cases, the unified API surface area kept expanding, requiring more custom logic on their end – defeating the entire purpose.
• Paying for auth, not infrastructure: Eventually reduced to using their provider just for authentication and proxy services. They were paying for integration infrastructure but getting a thin wrapper around APIs.Why Membrane

During their search for a solution again, Sequence found exactly what they were looking for and more with Membrane:

• Strong unified core: it has to be consistent and reliable across SaaS apps
• Real-time sync: fetch data from systems instantly with no delays
• Flexibility: work around the unified integration for edge cases/custom fields in an easy way
• Configurability: bake-in their own code, customize per customer or per SaaS app

Why Membrane: Infrastructure for building integration logic that works across every app

Membrane offered exactly what Sequence needed: integration infrastructure that handles both consistency and customization at scale:

Build integration logic once, apply everywhere: Membrane’s infrastructure lets you define how billing operations work – updating invoices, voiding transactions, syncing deal data – and then automatically adapts that logic to work with each app’s unique API structure.

Real-time operations by default: No sync cycles, no batch processing. When Sequence updates an invoice or voids a transaction, it happens immediately across all connected accounting systems.

Flexible customization without rewriting core logic: Need to handle custom fields in Salesforce? App-specific configurations for Attio? Per-customer schema mappings? Membrane’s infrastructure lets you customize without breaking the unified logic.

Critically, Membrane didn’t force Sequence to choose between building everything  themselves or accepting rigid abstractions. Membrane delivered infrastructure that handles the hard parts – authentication, API quirks, schema translation – while giving Sequence full control over integration logic.

“The two things that set Membrane apart are the flexibility and configuration options. You can configure per vendor and per customer at a very deep level. You can make custom queries, move data between environments and accommodate edge cases.”

Integration journey: 20+ integration scenarios in 2 weeks

The initial starting point for their implementation was integrating with accounting tools (Xero, QuickBooks) and CRMs (HubSpot, Salesforce, Attio).

Using Membrane’s Engine, Sequence defined integration logic once and applied it consistently across 20+ apps – while maintaining the flexibility to customize for app-specific requirements and per-customer configurations.

Core integration scenarios built:

1. Multi-CRM data orchestration

• List all deals from multiple CRMs at once into Sequence
• Get companies by ID from these deals across multiple CRMs simultaneously
• Unified query logic that works consistently across HubSpot, Salesforce, and Attio

2. Custom field mappings and schemas

• Implemented field mappings with a custom schema on the Sequence side and CRM side
• Defined how data correlates between Sequence and external apps
• Configured custom fields and customized each integration (e.g., Salesforce, Attio) separately without rewriting core logic

3. Real-time invoice operations

• Update invoices in multiple accounting systems when specific actions happen in Sequence
• Void invoices when specific actions happen in Sequence (applied to Xero)
• Operations happen in real time across all connected accounting systems

4. Seamless integration experience

• Built user-facing integration catalog showing available connections
• Customers connect their accounting and CRM systems with confidence that data will be available immediately

The Result: Build once, scale across every system

With Membrane, Sequence built their integration infrastructure in just 2 weeks.

• Integration speed: They were able to get integrations up and running much faster than expected – 2 weeks to production with 20+ integration scenarios live
• Core engineering focus: Choosing Membrane allowed all their engineers to stay focused on core product rather than building integrations from scratch
• Time to market: Sequence can ship features faster without redoing integrations each time

In the upcoming months, many more integrations are on the roadmap: sales tools, document management systems, and e-signature platforms.

With the integration infrastructure Sequence built using Membrane, adding new apps follows the same pattern: define the integration logic once, and Membrane’s infrastructure handles the complexity of adapting to each new app’s API. The unified logic they’ve already built for CRM and accounting workflows can extend to new categories without starting from scratch – they can reuse authentication patterns, schema mapping approaches, and real-time operation logic across their expanding integration ecosystem.