Fast content delivery: How Contentful achieves reliability and speed using its global CDN

At Contentful, we’ve built a comprehensive digital experience platform that includes a headless content management system with a composable architecture, enabling faster content delivery. This is backed by a fast, global content delivery network (CDN) and combined with world-class content ideation, creation, and curation tools.

This post explains how we designed our CDN, with advice that will help you choose the ideal CDN to deliver your own content and experiences to your audience, wherever they are, and whichever device is in front of them.

How the Contentful CDN ensures fast global content delivery 

The Contentful CDN delivers huge volumes of images, videos, text, and audio via highly performant and flexible APIs. Customers use our platform to deliver all of their digital content to their global audiences of thousands of companies and millions of users.

Our CDN ensures fast global delivery by serving content from “the edge.” This means that rather than having one server that serves content to all locations, servers are strategically located around the globe, close to where users are located. 

This presents two primary advantages: First, the connection count between the user and the hosting CDN is dramatically reduced by cutting out requests that reach across countries. Second, each CDN server is serving a much smaller number of users, meaning they have both the connection and CPU bandwidth to handle the requests for content.

To keep things running smoothly behind the scenes, the Contentful CDN constantly caches content at edge nodes, as it’s requested, and automatically routes traffic over the most optimal path, based on real-time network conditions.

Intelligent load balancing, smart cache invalidation, and continuous monitoring all work together to keep delivery speeds high, even during traffic spikes or regional outages. This provides an automatically elastic and scalable environment for developers, helping them build seamless experiences for users.

How we designed an effective CDN (and how you can do it too)

Having the right tools makes all the difference when it comes to delivering content quickly and reliably. Here’s what we looked for when choosing the components for the Contentful CDN:

1. Choose a platform that keeps responses cacheable

A major reason why our customers benefit from such incredibly low response times is that we understand their requirements for content delivery and have tailored our solution accordingly. 

We know that most of our customers don’t need to update their content very often, or only a small proportion of their overall repository is regularly refreshed. It’s far more efficient to serve content from a stored cache, which is how our customers benefit from really fast responses. Our fastest content availability, in effect, leans on the heavy caching and availability of the CDN without being fully dependent on it.

One of the CDN providers Contentful uses as the basis of our own CDN offers a global distributed PoP (Points of Presence) network, fast cache purging, and very flexible configuration. Building on top of that platform, we have worked on making it possible to purge the cache in targeted ways, providing the ability to serve stale content where it makes sense, and correctly caching certain kinds of API errors. We’ve also developed the ability to enact a rolling cache purge of the CDN without overloading our systems. 

With SEO as a baseline performance, caching on the CDN doesn’t just help during peak traffic times — it makes every request faster because the end user is physically closer to the server hosting the content. This directly benefits our users in a number of ways: Consistently low latency improves everything from SEO to user stickiness.

An origin request occurs when there is no cached copy on the CDN near the user and they have to make a request directly to our platform. We minimize origin requests as much as is feasible. Depending on the customer, our ratio of cached content to new content rarely falls below percentages in the mid-90s. More than nine out of every 10 requests are being served from the cache across all customers. So, for example, if we’re handling 35,000 requests per second, that’s significantly fewer requests hitting our platform.

All of this means that the digital product teams working with Contentful can update content without visible delays to end users. The CDN cache refreshes propagated content in near real time, effectively masking most origin updates made from end users to the origin servers.

2. Make sure your infrastructure can handle traffic surges (both expected and unexpected)

The ”thundering herd” problem occurs when you get an avalanche of origin requests, for example, when you purge the cache. This can also happen when you publish large chunks of content in preparation for a campaign, or you update live assets during a seasonal shopping event like Black Friday or Cyber Monday while there is a lot of traffic. In other situations, it might be a piece of content that goes viral or a new product announcement that is released and generates a lot of interest.

These critical moments are when our customers rely on us most, and Contentful is more than capable of handling these traffic spikes. By leveraging clustering, request collapsing, and shielding on our CDN, we reduce the pressure on the origin server so that it doesn’t have to do as much work.

These approaches reduce strain on the back end, delivering a direct improvement to the user experience (and making our DevOps lives easier because we don’t have fires to put out). Even when traffic surges to its highest peaks, visitors to your Contentful-powered experiences continue to see fast-loading content. 

On the occasions when an origin request is necessary, it is handled by our Kubernetes platform in AWS. We use the highly scalable application load balancers from AWS as our traffic ingress. Our applications run on elastic Kubernetes infrastructure that auto-scales to quickly handle extra traffic. The applications themselves also scale horizontally, adding or removing replicas based on the current load. We then prepare for key events and busy times of the year by adding extra capacity in preparation where necessary.

3. Choosing dependencies carefully

A composable architecture that combines best-in-class, third-party APIs with your own microservices and databases greatly assists when building rich experiences — however, you’re only as reliable as your least reliable component.

Even if your CDN is firing on all cylinders and providing the best possible content delivery performance, an unreliable third-party authentication, payment, or communication API can grind your app to a halt. Using a non-HA (highly available) managed cloud database instance or other third-party service might seem inconsequential, but if they only offer a 99% SLA, there will be consequences if they go down. Each delay risks user conversion by breaking product pages, impeding navigation, or signup user journeys.

Contentful offers a service-level agreement (SLA) that is specific to your plan and includes guarantees for up to 99.99% uptime. Internally, we define Service Tiers for services depending on the availability targets of the SLAs that they underpin; a Tier 1 service, such as our Delivery API, must not have a dependency that has a lower availability guarantee, be it internal or external.

So, to maintain our lean delivery path, we’re always asking ourselves whether we really need the extra dependency. Is it necessary? Could the data it provides perhaps be pre-computed and delivered by our CDN instead?

Contentful monitors the performance of all our dependencies, including uptime, latency, and SLA compliance, and evaluates actions if a service underperforms. This may include pre-caching its content or considering alternative solutions.

4. Build for failure

The key here is to identify failure domains and avoid crossing their boundaries — avoid putting all your eggs in one basket.

In distributed systems, it’s good practice to assume that calls made across the network between systems can and will fail in various ways. Requests can be refused, connections can break, and servers can crash, leading to responses that may take much longer than expected or fail to arrive at all. Our systems on the content delivery path employ the established best practices to mitigate this, including retries, timeouts, failing open when possible on feature flags, and circuit breakers.

Managing failure domains is also important. In systems architecture speak, a failure domain is a section of computing infrastructure that can be negatively impacted by a given type of fault. For example, AWS Regions (e.g., the venerable Northern Virginia “us-east-1” Region) are composed of multiple Availability Zones (AZs), each consisting of a group of computing resources that could potentially fail at the same time due to a power cut, bad code deployment, or networking issue. 

In this scenario, it’s a good practice to build computing infrastructure that spans at least two AWS AZs to ensure your platform stays up should an entire AZ fail. At Contentful, we deploy our Kubernetes clusters across at least three AZs and database clusters across at least two AZs.

Kubernetes clusters and database clusters are themselves a failure domain impacting all customers whose traffic goes through them or whose data they store. Therefore, we split customer data and traffic across multiple instances of each in a “shared-nothing” architecture, ensuring that issues with individual clusters are contained and have a limited impact.

We also have the option of routing traffic around a misbehaving cluster. On the content delivery path especially, we strive to keep all the necessary service dependencies local to the cluster dealing with the API request. We also set rate limits per space, so there’s a limit to how much each customer application can load the system. 

However, what if the entire AWS Region is down? For customers with the highest availability requirements, we replicate data and services using a multi-region delivery infrastructure that can handle Delivery API and GraphQL API requests, allowing our CDN layer to route 100% of requests during the outage. Because both regions are kept in sync, customers will experience uninterrupted access to their content, even during large-scale infrastructure anomalies.

With this resilience and redundancy, end users experience no downtime, clients experience no loss of performance, customer trust is preserved, and brands remain accessible.

Best practices for fast global content delivery

The following best practices will help ensure you deliver content quickly and reliably:

• Be wise with your content: Tailoring your content for different mediums, such as web, mobile, and social media, ensures the fastest delivery and appropriate scale for the target platform. The Contentful Images API can optimize assets for the best delivery, while tagging your media helps organize your content. Tagging also lets the Asset API understand which asset best fits a given channel based on context and device, among other factors.

• Enable failover for continued availability: When a region or network struggles or services are knocked offline, fallback nodes can provide extra support, making issues less apparent and ensuring the core content path remains. Contentful’s distributed architecture and regional failover routing ensure continued content availability. This helps teams maintain a seamless user experience, even during infrastructure incidents.

• Use CDN edge caching: Contentful’s global CDN automatically caches responses at the edge. Specialized CDN servers used for read-only requests and hyper-fast, local delivery of content ensure that repeat requests are served instantly from nearby locations, minimizing latency and improving consistency under load.

• Leverage dynamic asset transformations: Pre-process expensive media operations, like format conversion or image optimization, and cache the result in your CDN. You can use the Contentful API to dynamically resize and crop images to reduce payload size, and if you use our CDN, the result is automatically cached at the edge.

• Combine API queries for greater agility: GraphQL enables efficient queries that fetch only the data needed per page or component. This helps to reduce payload bloat and unnecessary network roundtrips. You can also combine multiple queries for greater performance.

• Ensure performance with proactive monitoring and alerting: It’s vital to use proven monitoring tools to collect data on network performance. You should be tracking data points such as requests per second, latency percentages, and error rates across API regions. Be sure to compare live metrics with historical baselines to detect deviations. Collect metrics from edge caches, such as hit versus miss ratios and geographical distributions. All of this will help you spot demand spikes and degraded performance.

• Use anomaly detection: Use visualization tooling and dashboards to make metrics and data points easy to digest. Define alert thresholds for when live metrics drop below the established baselines, trigger notifications to team members, and enable effective mitigation at critical times.

• Log effectively: Well-designed metrics help identify traffic surges or latency spikes and provide the why to which endpoint, customer, or region caused a change in performance. Trace IDs help correlate requests across services to identify which component in a distributed system is introducing latency. Generating detailed logs helps follow up with post-incident analysis when investigating root causes, reconstructing events, later improvements to runbooks, etc.

• Leverage analytic intelligence: Agentic content analytics use AI tools to quickly analyze your logging and network metrics. To benefit from this, you need to know your network infrastructure well. Instead of passively observing the data displayed on the analytics dashboard, actively asking questions about the metrics helps you gain deeper insights into how your content performs. This approach allows you to identify which elements drive positive results and help uncover patterns across your portfolio.

An effective content platform for fast content delivery (and so much more)

These CDN implementation best practices have enabled Contentful to sustain exceptional performance and availability for our customers through high-traffic events like Black Friday, Cyber Monday, and even the unexpected viral explosion of user-submitted content.

If you’re building a CDN for your apps, websites, billboards, digital assistants, or pretty much anything else, consider whether you actually have to — it’s a significant, ongoing technical undertaking, and we’ve already done all the hard work for you. Contentful has built a globe-spanning CDN into our digital experience platform. Alongside providing the most effective CMS, we boast world-class content creation and curation tools that were created to address the real needs of our creative and developer community.

We also help you out on the front end with REST and GraphQL APIs and SDKs for popular languages and frameworks, making it straightforward to connect any client to your globally distributed content. To see what Contentful’s digital experience platform and leading CDN infrastructure can do for you, get in touch for a personalized tour and demonstration.

Take a tour

Chat with our team

Your experiences should wow, not wait. Let's talk.