Subtrace wants to put an inspect element button on your entire backend

Every backend engineer knows the specific dread of an incident they cannot see. An alert fires. A customer says checkout failed. The dashboards show a spike in 500s, and the traces show a slow span somewhere in the middle. But the one thing you actually want - the request itself, the exact payload and headers that broke - is scattered across four services and a retention window that already expired. Subtrace, a company out of Y Combinator's Winter 2025 batch, is built around a simple bet: that engineers would rather see the request than a percentile.

Its pitch fits in one line. "Subtrace is like having an inspect element button for your whole infrastructure." When you start a process with it, you see every HTTP request coming in and going out, in real time, laid out in an interface that deliberately looks like the Network tab in Chrome DevTools. The company describes the category with two borrowed metaphors at once - part Wireshark, part browser console - and both do real work in getting an engineer to understand it in under five seconds.

01 / The problemWhy the logs never have what you need

The founders' argument with the status quo is specific. Tools like Sentry and OpenTelemetry are good at telling you that something broke and roughly where. They are less good at showing you the raw request that caused it. Errors get sampled. Traces get summarized. Bodies get dropped for cost or privacy reasons. So when an engineer needs to root-cause a failure, the reconstruction begins: grep one service, correlate a trace ID, guess at the payload, and try to reproduce it locally. Subtrace's framing is that this is a data-retention problem disguised as a tooling problem. The detail you need was there for a moment, and your monitoring threw it away.

That is the gap Subtrace aims at: keep the whole request - payload, headers, latency, status - and make it searchable and replayable, so debugging starts from evidence instead of a hypothesis.

02 / How it workseBPF, and the missing setup step

The technical decision that makes the rest possible is capturing traffic at the network layer with eBPF - the Linux kernel technology that lets you observe system events safely without patching applications. Because Subtrace taps the network rather than your code, there is no SDK to import, no instrumentation to sprinkle through your handlers, and no root privileges required. The setup step that usually gates adoption - deploy an agent, wire up a collector, redeploy your services - is largely deleted.

# start your server with tracing, nothing else changes
$ subtrace run -- node server.js
# or wrap a Python service
$ subtrace run -- uvicorn app:main
# works inside Docker, Docker Compose, and Kubernetes

Once traffic is flowing, the interface is where the browser metaphor pays off. You filter requests with simple parameters, click one to see its full contents, copy it as cURL, and replay it. For a web developer, none of this needs a manual - the muscle memory is already there from a decade in the browser. That is the quiet product principle underneath Subtrace: familiarity is a feature, and borrowing an interface people already trust drops the learning curve close to zero.

03 / The peopleDomain scars, sharpened into a product

Subtrace was founded in 2024 by Adhityaa Chandrasekar and Sachin Sridhar. Chandrasekar, the CEO, was a software engineer at Google working on Kubernetes internals and GKE infrastructure monitoring - which is to say he spent his time inside exactly the kind of system Subtrace is meant to observe. Sridhar, the CTO, came from Microsoft, where he worked on Power BI and Microsoft Fabric. Both studied at IIT Madras; Chandrasekar also spent time at the University of Waterloo. Around the web he goes by one handle almost everywhere - "adtac" - which is his GitHub, his X account, and his LinkedIn URL.

The backgrounds matter because the product reads like it was built by people who had the problem, not people who surveyed for it. On-call rotations at that scale teach a specific lesson: the outage you fear is not the one that pages you, it is the one you cannot reproduce afterward. Record-and-replay is aimed straight at that fear.

04 / The differenceRaw request beats summarized dashboard

Against the incumbents, Subtrace's differentiation is less about a feature list and more about a stance. Datadog, Sentry, and OpenTelemetry are broad observability platforms that sample and aggregate; they excel at trends and alerting. Wireshark captures packets but was never meant for the modern container-per-service backend. Subtrace sits in the space between: full request-level fidelity, captured with zero code, presented in a familiar console. The chart below is directional rather than benchmarked, but it captures the tradeoff the company is selling.

The risk in this position is obvious and worth naming: capturing every request raises real questions about volume, cost, and sensitive data. Subtrace's answer so far is architectural - tap efficiently at the kernel, filter early - but how it handles retention and redaction at scale is the part of the story still being written.

05 / The modelOpen source as the front door

Subtrace's core tracer is open source under a BSD-3-Clause license, and it gathered a following - roughly 2,800 GitHub stars - ahead of the company being widely known. For a tool that sits in the path of production traffic, that openness is a trust strategy as much as a distribution one. Engineers are far more willing to run something on their servers when they can read exactly what it does. The Linux build ships openly via an install script; the macOS build launched as a private beta with a waitlist.

The business, as with most open-core developer tools, is expected to live in the hosted layer on top - storage, search across history, collaboration, and team features - rather than in the tracer itself. Pricing is not public. The go-to-market is bottom-up: an engineer tries it on one service, it proves useful during a real incident, and it spreads sideways through the team. That pattern showed up early with Trieve, a fellow YC company (W24), which used Subtrace in production and reported cutting incident resolution time from months to minutes.

06 / The marketWhere it fits, and what to watch

The observability market is crowded and well-funded, which cuts both ways. It means Subtrace is entering a category buyers already have budget for, and it means it is standing next to companies with far more headcount. The two-person team is a feature of the story rather than a caveat: developer tools spread by usefulness, and a tight team shipping an open-source product that engineers actually reach for is a familiar early shape for this kind of company. What to watch next is whether Subtrace can turn a beloved local tracer into a hosted platform teams pay for, and whether the full-fidelity capture holds up on cost and privacy as usage grows.

For now, the appeal is concrete. If you have ever reconstructed a failed API call by hand at 2am, Subtrace is offering to hand you the call instead. That is a small promise, precisely scoped, and in developer tools the precisely scoped promises are usually the ones that travel.