CodSpeed: Continuous Performance Testing for Your CI

PERFORMANCE CONFIDENCE IN CI

CodSpeed delivers continuous performance testing and autonomous performance optimization right in your PR, so you can focus on building.

Start for Free Book a Demo

PERFORMANCE CONFIDENCE IN CI

CodSpeed delivers continuous performance testing and autonomous performance optimization right in your PR, so you can focus on building.

Start for Free Book a Demo

Trusted by fast-moving teams

Trusted by fast-moving teams

Putperformance

on —autopilot

Putperformance on

—autopilot

CodSpeed delivers continuous performance testing and autonomous performance optimization right in your PR, so you can focus on building.

A release roadmap progressing while CodSpeed profiles each commit

Focus on building

Don't let performance debt derail your roadmap. CodSpeed handles code profiling automatically, ensuring your release cycles stay fast without the need for manual benchmarking.

Focus on building

Don't let performance debt derail your roadmap. CodSpeed handles code profiling automatically, ensuring your release cycles stay fast without the need for manual benchmarking.

CodSpeed surfacing a bottleneck and its suggested fix automatically

Stop the manual grunt work

Don't waste senior engineering hours on manual code profiling. Our AI identifies performance bottlenecks and suggests fixes, so your builders can focus on innovating instead of debugging.

A latency chart held flat under an SLA threshold

Meet all your SLAs

Prevent lags before they reach your users. By automating performance monitoring, you ensure a world-class user experience and protect your revenue without slowing down.

Performance issues are hard to see and easier to miss

The gap isn't in the models. It's in the layer of infrastructure that connects agents to the world they need to operate in. Without it, every production deployment becomes a months-long custom engineering project — fragile, expensive, and hard to govern.

See how CodSpeed solves this

Engineering time drained by manual performance debugging

Code reviews don't show performance problems

Slow code looks the same as fast code.

CI benchmarks are noisy and unreliable

Different machines, different results.

Introducing codspeed

Continuous performance confidence across your workflow

CodSpeed handles benchmarking, profiling, and regression checks in CI so your team can focus on building features — not chasing slowdowns.

A CodSpeed benchmark run reporting variance below one percent

Get trustworthy metrics

Stop chasing ghosts in your CI. CodSpeed automatically isolates relevant performance data to bring benchmarking variance below 1%, giving you rock-solid results without the need for manual re-runs or second-guessing.

See how this works

A differential flamegraph with a Root Cause Detected callout ranking the slowest calls

Pinpoint root causes

Stop digging through logs. CodSpeed’s AI-enhanced differential flamegraphs automatically surface exactly which lines of code got slower, revealing exactly what changed so you can jump straight to the fix.

See how this works

A pull request opened by the CodSpeed agent with an auto-generated fix, benchmarked 23% faster

Fix it automatically

Stop fixing performance issues by hand. CodSpeed’s Optimization Agent takes the root cause it found, applies the fix, benchmarks the result, and opens a pull request ready for your review.

See how this works

Raw tracing samples being filtered into a clean measurement

Eliminate noise

Our instruments do the heavy lifting by collecting high-precision tracing data and filtering out system jitter, delivering only the clean, actionable performance monitoring insights you need.

See how this works

A pull request check blocking a merge that slowed execution

Uphold performance standards

Maintain a high-performance culture with automated performance gating. Automatically block merges that degrade your execution speed, ensuring every change meets your standards.

See how this works

Rust, Python and Node.js benchmarks reporting into one pull request

Integrate with your stack

Deploy performance testing across your development workflow. CodSpeed supports Rust, Python, Node.js, and more, bringing reliable benchmark testing directly into your pull requests.

See how this works

Start for Free See productSee the full product

SUCCESS STORIES

What builders are saying

Real feedback from engineering teams using CodSpeed in production.

CodSpeed has become a key part of the development loop for the Astral toolchain (Ruff, uv, and ty). While continuous benchmarks are typically viewed as challenging and unreliable, with CodSpeed, we get stable, end-to-end and instrumented benchmarks that allow us to avoid regressions and maintain a high-performance culture.

Charlie Marsh

Founder & CEO, Astral

CodSpeed has transformed our development workflow. We can now ship with confidence, knowing performance issues are caught long before they reach our users.

Samuel Colvin

Founder & CEO, Pydantic

Seeing clear, consistent results on every PR motivates the whole team to improve performance and avoid regressions before they land. CodSpeed is making performance everyone's responsibility.

Yagiz Nizipli

Node.js Performance Expert

Charlie Marsh

Founder & CEO, Astral

Samuel Colvin

Founder & CEO, Pydantic

CodSpeed has transformed our development workflow. We can now ship with confidence, knowing performance issues are caught long before they reach our users.

Yagiz Nizipli

Node.js Performance Expert

Seeing clear, consistent results on every PR motivates the whole team to improve performance and avoid regressions before they land. CodSpeed is making performance everyone's responsibility.

QUICK SETUP

Get started in minutes

Define benchmarks that monitor performance across your entire codebase.

Start for free

benches/my_bench.rs

use fibonacci::fibonacci;

#[divan::bench]
fn bench_fibo_20(){
  fibonacci(20);
}

fn main() {
  divan::main();
}

my_bench.cpp

#include "fibonacci.h"

static void BM_Fibo_20(benchmark::State &state) {
  for (auto _ : state) {
    fibonacci(20);
  }
}
BENCHMARK(BM_Fibo_20);
BENCHMARK_MAIN();

fibo.go

import "testing"
import "fibonacci"

func BenchmarkFibonacci20(b *testing.B) {
  for b.Loop() {
    fib(20)
  }
}

tests/test_my_fibo.py

import pytest
from my_fibo import fibonacci

@pytest.mark.benchmark
def test_fibo():
    return fibonacci(20)

fibo.bench.js

import { bench, describe } from "vitest";
import { fibonacci } from "./myFibo";

describe("fibo", () => {
    bench("fibo 20", () => {
        fibonacci(20);
    });
});

src/jmh/java/FibBenchmark.java

import org.openjdk.jmh.annotations.Benchmark;
import static my.fibo.Fibonacci.fibonacci;

public class FibBenchmark {

  @Benchmark
  public long benchFibo20() {
    return fibonacci(20);
  }
}