PlatformIntegrationsResourcesDocsPricing
ContactLog inSign up
Intro to Composable Architecture
The Modern Enterprise Stack
The Rise of Composable Architecture
Key Parts of a Composable System
Microservices & Serverless Functions
How Microservices Work
Benefits of Microservices
Challenges of Microservices
Serverless Function Providers
The Backend: Databases & Headless CMS
Working with Composable Content
Types of Backend Services
Benefits of Decoupled Content
Common Challenges with Decoupled Content
Choosing the Right Backend Service
The Frontend: Web Frameworks
The New "Frontend"
Site Framework Considerations
Modern Frameworks for Enterprises
Content Editing in Composable Systems
Editing Experience in Monolithic Systems
Headless Editing Experiences
Visual Editing Services
Composable Content
Multi-channel Developer Challenges
Homegrown Content Meshing Solutions
Vendor-based Composable Systems
CI/CD: Building, Deploying, & Hosting
CI/CD for Monolithic Applications
The Build Pipeline
Build & Deployment Services
Common Website Features & Tooling
Authentication
Analytics
Personalization & A/B Testing
Form Submissions
Search
Common Enterprise Challenges
Technology Cost
Security
Traffic & Scalability
Page Speed Performance
Code Complexity
Continuous Integration & Delivery
Getting Started: Migration Strategies
Gradual Migration
Evaluating Tools & Services
Wrapping Up: Is Composable Worth It?

Homegrown Content Meshing Solutions

Multi-channel Developer ChallengesVendor-based Composable Systems
Trust CenterPrivacySecurityGDPR/CCPAAbuse
©2023 Netlify
On This Page
Challenges with middleware systems
Taking advantage of GraphQL

Until recently, if an enterprise wanted a source of truth for content from multiple sources, they would have to create their own middleware between frontend code and various content sources.

Challenges with middleware systems

Building this sort of system sounds simple — you query a few APIs, stitch them together, and deliver content via a unified API that the frontends access. Thus, all content flows through this mechanism.

In practice, it becomes challenging immediately. Getting the content is the easy part. Stitching and delivering is the really hard part. It takes knowing how your frontends are going to use the information and caching effectively so that the frontends get the content as quickly as possible.

Taking advantage of GraphQL

One tool that has helped enterprises in this regard is GraphQL. GraphQL is a query language (that’s what “QL” stands for) developed by Facebook to help control the number of queries sent by any given page. GraphQL is built for simplifying the complex query needs of a single view in an application. Thus, it’s a great fit to solve many of these stitching problems.

However, GraphQL doesn't solve the challenges of stitching content together on its own. It requires additional orchestration to effectively serve as content middleware. You'd still have to manage the infrastructure of your GraphQL service, while handling the caching and coordination of the various content sources.