How Storyblok built integration infrastructure that scales across their entire content ecosystem

Goals

• Cut development time from weeks to days for each new integration
• Build scalable infrastructure that handles authentication, data mapping, and storage without custom backend work
• Focus engineering time on business logic, not integration plumbing

Highlights

• Built custom Algolia connector in hours instead of weeks of custom development
• 1 day to ship new integrations vs. 2 weeks before Membrane
• 10 engineers trained and productive in under 30 minutes each
• Infrastructure that handles complexity: Non-standard auth flows (Shopify), GraphQL customization, per-customer data storage

Company Overview

Founded: 2017
Industry: CMS / SaaS
Number of employees: 245
Location: Remote / Austria

Website: https://www.storyblok.com/

Storyblok is a headless Content Management System (CMS) that provides highly customizable content blocks and visual editing tools designed for both technical and non-technical users. Teams across education, commerce, gaming, and publishing use Storyblok to manage content that appears across websites, apps, and digital interfaces.

The company has raised $138M to date, including a Series C from Brighton Park Capital, and is positioned as a leader in the CMS space. Over 200,000 developers and marketers from brands like Adidas, T-Mobile, Renault, and Oatly use Storyblok to consolidate content and create better digital experiences across all channels.

For Storyblok, integrations aren’t a feature – they’re foundational to becoming the content hub for modern digital experiences. Without deep connectivity to e-commerce platforms, collaboration tools, search engines, and analytics systems, Storyblok’s content stays isolated instead of powering the full customer journey.

The Challenge: Scaling to dozens of integrations at speed

Storyblok was on a path to accelerate connectivity with dozens of business applications. As a modern, leading CMS, they needed to expand and become a powerhouse in terms of working with other SaaS products.

Given their ambition to integrate with dozens of new apps, they knew they had to build robust infrastructure to handle customer-facing integrations – not just ship one-off connections. Building every integration in-house was not a scalable solution: 

• At least 6 months to arrive at robust integration infrastructure
• Significant engineering time diverted from core product development
• 2 weeks per integration to ship and get to production

They needed a solution that would accelerate integration development without sacrificing control or flexibility. In particular, Storyblok was looking for a solution that could:

• Handle the whole infrastructure: Authentication management, data mapping, per-customer storage – so Storyblok engineers could focus only on business logic
• Easy-to-use data schemas that work efficiently across multiple integrations
• No limitations on background jobs: Ability to run long-running processes to fetch stories from Storyblok
• Configurability: Ability to customize per customer, per app, and inject custom code where needed

Why embedded iPaaS platforms didn’t work:

Storyblok evaluated traditional iPaaS platforms like Tray.io, but they ran into fundamental limitations:

• No support for long-running background jobs: Timeouts prevented Storyblok from efficiently syncing large content libraries
• Limited schema flexibility: Couldn’t efficiently define and manage data schemas across multiple integrations

Why open-source alternatives didn’t work:

Storyblok also evaluated Nango. The open-source aspect initially appealed to Storyblok – keep everything in their own Git repo, version control it, and have flexibility on deployment. But the reality was different:

• Still time-intensive: Only the auth layer was provided for core apps. Engineers still had to write significant custom code for each integration.
• Limited pre-built functionality: Missing the abstractions needed to focus on business logic instead of API plumbing

Storyblok needed infrastructure that handled the hard parts – auth, data mapping, storage, API quirks – while giving them full control over business logic and customization.

Why Membrane: Infrastructure that handles back-end complexity

Membrane ticked all the boxes, offering customizable infrastructure for creating integrations at scale, without adding engineering headcount or complexity.

• Abstraction layer for authentication and data: Engineers could focus only on business logic, not API plumbing
• Full configurability: Inject custom code, customize per customer or per app, and control every aspect of integration behavior
• Per-customer data storage: Use configurable schemas to store metadata instead of building their own database
• Reactive support: Minutes instead of weeks to get answers to technical questions

“It took 30 minutes to understand the concepts and how Membrane works,” Eunjae Lee, Lead Engineer at Storyblok explained*. “Once I got the hang of it, I recorded videos and trained 5 engineers on the team how to use it. It’s a really powerful tool, and the scope is unmatched.”*

Implementation Journey: production-ready integrations in hours

Storyblok’s evaluation process centered on two real-world challenges that would validate whether Membrane could handle their most complex requirements.

1. Building the Algolia Search integration from scratch

None of the integration products evaluated by Storyblok had a pre-built Algolia connector, so part of the evaluation was to build the Algolia integration from scratch: first the connector, then integration flows for pushing stories to Algolia.

Algolia’s API required custom field mappings and real-time sync capabilities to power search experiences across Storyblok customers’ websites. Using Membrane’s Engine, Storyblok could generate the integration logic they needed and customize it for their specific use case. This meant Storyblok was able to build a custom Algolia integration in just a few hours instead of weeks.

Display Shopify product data on websites built with Storyblok

The Shopify integration posed its own set of challenges – ones that exposed the architectural limitations of competing platforms:

Challenge 1: Non-standard authentication Shopify’s authentication mechanism was highly non-standard. It needed to originate from the Shopify app store, go through Storyblok’s app, through the integration platform, and then back to Storyblok.

Membrane was the only product that could handle this complexity using custom callback URLs and related functionality.

Challenge 2: GraphQL API customization Shopify’s API is built on GraphQL, and Storyblok needed to customize API requests – something most integration platforms don’t support.

Membrane’s infrastructure handled this use case seamlessly, allowing Storyblok to define custom GraphQL queries and mutations as part of their integration logic.

“Once I understood the concepts, it was incredibly fast to build,” Eunjae reflected. “The platform gives you the infrastructure you need – authentication, data schemas, background jobs, per-customer storage – and lets you focus on the business logic.” 

The Result: unlimited SaaS connectivity

With Membrane, Storyblok built integration infrastructure that enables their engineers to focus on business logic while Membrane handles the complexity. It reduced their time to ship integrations from 2 weeks to 1 day. 

“It gives our team a peace of mind and increased confidence to have a partnership with a company like Membrane,” said Sebastian Gierlinger, VP of Engineering at Storyblok.

The impact wasn’t just faster shipping – it was a fundamental shift in how Storyblok’s engineers spend their time:

• Before Membrane: Engineers spent weeks per integration building auth layers, managing API quirks, and maintaining custom backend infrastructure
• After Membrane: Engineers focus exclusively on business logic while Membrane handles authentication, data schemas, and per-customer storage

“Given a lot of the backend infrastructure is handled by the platform, our engineers are free to focus on building better business logic,” Eunjae explained.

What’s Next: Scaling across the content ecosystem

Since partnering with Membrane, 10 Storyblok engineers have learned how to use the platform and are actively working on new integrations – Microsoft Teams, additional e-commerce platforms, analytics tools, and more.

The integration infrastructure Storyblok built with Membrane enables them to:

• Expand rapidly across new categories: From the initial focus on search and e-commerce, Storyblok is now building integrations across collaboration tools, marketing platforms, and analytics systems
• Support per-customer customization: The same infrastructure that powers standard integrations can be customized for enterprise customers with unique requirements
• Maintain velocity as complexity grows: As Storyblok adds more integrations and more customers, the infrastructure continues to handle backend complexity while engineers focus on business logic

Storyblok’s integration infrastructure isn’t just enabling faster development today – it’s positioned to support the next generation of content experiences as the ecosystem continues to evolve.