Network performance update: Developer Week 2022

How Cloudflare’s network stacks up in Developer Week 2022

Cloudflare has long claimed to operate the fastest network in the world, and to back that up, it continuously benchmarks itself against competitors. For Developer Week 2022, the company expanded its testing to include AWS Lambda@Edge alongside Fastly’s Compute@Edge, in addition to updating its general network performance data. The results, according to Cloudflare, show that its Workers platform is the fastest developer platform available.

Network performance: the latest numbers

To measure global network performance, Cloudflare relies on Real User Measurements (RUM). Users around the world fetch a 100kB file from different providers, and the collected data helps determine where each provider is faster. The company shared two snapshots: one from Cloudflare One Week (June 2022) and one from Developer Week (November 2022). Both look at the top 3,000 networks worldwide, ranked by number of advertised IPv4 addresses, and count how often each provider ranks first in p95 TCP Connection Time.

Cloudflare also maps this data by country. Comparing the two periods, Cloudflare gained the number one spot in more countries across Europe and Asia, including Russia, Ukraine, Kazakhstan, India, and China.

How developer platforms are compared

Cloudflare’s developer platform comparisons measure three key metrics: connect time (time to reach the network), wait time (time spent computing the request), and response time (total end-to-end latency). Connect times are reduced by peering close to users, while wait times depend on how well the platform optimizes code execution.

Three tests are run against each provider:

• A simple no-op JavaScript function
• A complex JavaScript function
• A complex Rust function

There is no simple Rust test, since it would take negligible time and the no-op JavaScript already establishes an end-to-end baseline, especially since many providers compile both languages down to WebAssembly. AWS Lambda@Edge was excluded from the Rust tests, however, because it does not natively support Rust without manually uploading a compiled WASM binary. Therefore, Lambda@Edge results only cover the JavaScript tests.

The actual functions used in the tests are as follows:

async function getErrorResponse(event, message, status) {
  return new Response(message, {status: status, headers: {'Content-Type': 'text/plain'}});
}

function testHardBusyLoop() {
  let value = 0;
  let offset = Date.now();

  for (let n = 0; n < 15000; n++) {
    value += Math.floor(Math.abs(Math.sin(offset + n)) * 10);
  }

  return value;
}

fn test_hard_busy_loop() -> i32 {
  let mut value = 0;
  let offset = Date::now().as_millis();

  for n in 0..15000 {
    value += (((offset + n) as f64).sin().abs() * 10.0) as i32;
  }

  value
}

Data collection and methodology

The results come from two sources. The first is Catchpoint, a synthetic monitoring platform with roughly 2,000 endpoints globally. For this test, Cloudflare selected 300 backbone nodes embedded in last-mile ISPs, filtering out cloud providers and metro areas with multiple transit options to avoid duplicate paths. While these nodes sit inside ISP networks like real users, they use dedicated bandwidth, so they do not fully replicate home Internet conditions.

The second source is Cloudflare’s own data set, collected from users who hit 1xxx error pages on free websites. Those pages execute the same tests during rendering and upload performance metrics back to Cloudflare.

One important change: this round of testing used paid accounts for Cloudflare, Fastly, and AWS, avoiding any potential bias from free-tier limitations.

Workers versus Compute@Edge versus Lambda@Edge

The overall response time results show Cloudflare is fastest in every scenario tested.

Connect time results follow a similar pattern. These numbers are not expected to vary by workload, since they measure how quickly a user reaches the platform before any code runs, but they are broken out from the same tests for completeness.

Wait time represents the actual compute phase. Here, Cloudflare is again ahead in most tests, although Fastly retains a slight edge on the hard Rust test. The wait time results are:

To cross-check the Catchpoint data, Cloudflare compared it against its own RUM-based measurements. The p95 TTFB results for the JavaScript and Rust hard loops across Fastly, AWS, and Cloudflare confirm the Catchpoint findings: Cloudflare is faster on JavaScript and Rust calls, while Fastly holds a minor advantage on the Rust compute test.

Why network performance matters for developers

Latency directly shapes user experience, and for developers, minimizing it is often critical to an application’s success. Cloudflare argues that running code on its network—whether in Workers, D1, or R2—delivers the best possible user experience because the platform is built on top of the company’s broader network infrastructure. The claim is simple: the faster the underlying network, the faster the applications that run on it.