The 0% Wall: Why My WebSocket MEV Bot Can't Land Anything

The Number That Won't Move

My landing rate is zero. Not 0.4%. Not 0.04%. A clean, embarrassing zero. The bot wakes up, scans pools, finds what look like profitable cycles, builds the transaction, fires it off — and lands nothing. Day after day. The logs fill up with "opportunity detected," then nothing on chain.

I keep wanting to blame the code. There must be a bug somewhere — a miscalculation, a stale account, a slow path. So I sit down and trace the pipeline again. The math checks out. The transactions are well-formed. The cycles look real at the moment I detect them. And then they evaporate before my submission gets included. Every time. Always the same way.

It's taken me longer than I'd like to admit to accept what's actually happening: the bug isn't in my code. The bug is in my assumption that being on the public data feed at all is enough to compete.

What I Thought I Was Building

The original plan was simple, and felt reasonable in week one. Subscribe to account updates over WebSocket. When a pool's reserves change, recompute prices across the cycle. If a profitable path appears, send the swap.

WebSocket made sense as an entry point. It's the default streaming interface every Solana node ships with. Most tutorials use it. The protocol is text-based, easy to debug — open a terminal, log every message, watch the bot "see" the chain in real time. For someone learning, it felt like progress.

The trouble is that "works in a tutorial" and "wins a race against other bots that have been doing this for years" are not the same problem. I was solving the first one. I'm now staring at the second one.

What the Public Data Feed Actually Is

Here's the part I missed at the start. A WebSocket subscription to a public RPC endpoint is, by design, a broadcast channel. Every searcher who connects to the same endpoint receives the same updates at roughly the same time. There is no information edge. Everyone watching the same pool sees the same reserve change in the same window.

This is a coordination disaster. Per an analysis of the Solana bot landscape, on competitive launches "dozens of automated bots compete to be the first buyer" in under two seconds — all looking at the same data, all converging on the same trade, all submitting essentially together. (Quasa.io)

The network picks exactly one winner per opportunity. Everybody else burns CPU and submission fees for nothing. That's the structural shape of the game I walked into.

The Latency Floor I Can't Push Through

The first thing I did, of course, was try to be faster. Smaller payloads, tighter parsing, a closer region, a paid endpoint instead of a free one. Each change gave me a few milliseconds. None of it changed the landing rate.

Why not? Because the public WebSocket layer itself has a latency floor that's higher than the floor my competitors are operating on. Per a technical comparison, standard WebSocket subscriptions deliver data with latency in the 100–300ms range, while validator-memory-tapping gRPC streams operate at sub-50ms. (Chainstack)

Daniel Yavorovych, writing about Solana MEV infrastructure in March 2026, puts it bluntly: a bot reading prices from a public RPC endpoint "is already 200ms behind the bots co-located next to validators." (Yavorovych, Medium)

Two hundred milliseconds. That's not a tuning problem. That's a category problem. You can't out-tune your way across a different category of access.

Why the Protocol Itself Holds Me Back

The latency is the headline, but the architecture underneath has matching weaknesses. From the same technical writeup, the public WebSocket interface has a few characteristics that bite you specifically when you're trying to do MEV:

• Data arrives as base64 blobs that have to be decoded client-side before you can do anything with them.
• Subscriptions only see events from the moment you connect — there's no replay if you miss something.
• You can't ask the server "only notify me about this token" — filtering is your job, after the data has already crossed the wire.
• Connection-level caps on the number of subscriptions per socket force you to spread state across multiple sockets, which adds bookkeeping and jitter.

Individually, none of these are dealbreakers for a casual integration. Collectively, in a race where the winner is determined by tens of milliseconds, they're a tax that compounds. My bot is doing extra work to assemble a coherent picture of the world while the competition is reading a pre-built picture directly.

This is the part where I finally stopped thinking of WebSocket as "the entry-level option I can upgrade later" and started thinking of it as "the wrong tool for this specific job, period."

The 98% That Lose

The most uncomfortable number in this research, the one that explains my zero, comes from analysis of arbitrage activity on Solana. According to research data cited by Coinfeeds.ai (drawing from Jito Labs work), in any given epoch over 60% of block compute units are consumed by arbitrage transactions, and over 98% of those arbitrage attempts fail. Only the first successful arb in each race wins. The rest pay for compute they got nothing from. (Coinfeeds.ai)

A MEV report adds a complementary measurement: at the April 2024 peak, 75.7% of all non-vote transactions on Solana were reverting, largely because "many MEV bots engaged in spamming arbitrage transactions." (Helius MEV Report)

Let that picture sit for a second. The network was, at its busiest, mostly carrying failed bets. Bots that didn't have an infrastructure edge were essentially paying to lose, in volume. That's not a niche statistic about a few unlucky teams. That's the median experience.

And my bot, sitting on the public WebSocket layer with no Jito bundle path and no co-location, is firmly inside the 98%. Possibly inside the 99.9%. The reason I have a zero is that the system is designed, by competitive pressure, to give people in my position a zero.

Where the Money Actually Goes

When I look at where MEV revenue on Solana ends up, the asymmetry is brutal. Analysis from Solana Floor shows a single sandwich bot identified by the address starting E6Y is responsible for 42% of all sandwich volume on Solana, processing $1.6 billion in trades in a recent thirty-day window with roughly 1,646 SOL of daily profit. (Solana Floor)

Cross-chain analysis from Extropy Academy confirms the concentration: the top three sandwich bots combined account for over 60% of the market. (Extropy Academy)

A report frames the broader arbitrage picture: roughly 90 million successful arbitrage transactions over the year, $142.8 million in total profits, averaging $1.58 per trade. (Helius) That tiny per-trade average is itself a tell — it says the survivable strategy is enormous volume at tiny margins, executed by a few outfits with cost structures most independent operators can't match.

If the market is shaped like a winner-takes-most pyramid and I'm building at the base on commodity infrastructure, my zero stops being a mystery. It's the predicted outcome.

The Infrastructure Gap I Hadn't Priced In

What are the people at the top actually running? The picture from infrastructure-focused writeups is consistent. Yavorovych summarizes the stack as bare-metal servers physically co-located with high-stake validators, fed by gRPC streams operating in the single-digit-millisecond range, submitting through validated bundle paths in parallel. Co-location alone, per the same source, delivers a 5–10× latency improvement over remote endpoints. (Yavorovych)

A guide cites monthly costs of $1,800–$3,800 for the kind of dedicated, high-performance RPC nodes serious MEV operations rely on. (RPC Fast) That's just the data layer. It doesn't include the co-located machines, the connectivity, or the engineering hours to keep all of it working.

What that buys, in practice, is participation in a different race than the one my bot is running. Mine is competing in something like an amateur charity 5K where everyone shows up in sneakers. Theirs is the NASCAR equivalent — purpose-built machines, full pit crew, telemetry from sensors that don't exist on my dashboard. Buying nicer sneakers doesn't move me onto their track.

The Submission Side, Which I Hadn't Even Started Thinking About

Everything I've described so far is about detecting opportunities faster. But there's a parallel problem on the submission side that the public WebSocket path doesn't address at all.

On Solana, a meaningful chunk of MEV competition runs through Jito's bundle infrastructure. Per a MEV report, validator adoption of the Jito-Solana client grew from 48% of total stake in January 2024 to 92% by January 2025. (Helius) That means nearly the entire network is participating in tip-based bundle inclusion. A bot submitting via standard RPC is, in effect, trying to win a race where the lanes go to whoever has paid for them.

Yavorovych's framing: a bot submitting through standard RPC "loses to bots that prioritize execution based on tip efficiency." Even if my detection were as fast as theirs, my path into the block isn't competing on the same terms. (Yavorovych)

So there are actually two zeros stacked on top of each other for someone in my position. The detection zero (I see things later than the leaders) and the submission zero (even if I saw them at the same time, my submission path isn't competing on tip efficiency). They multiply.

The TrumpCoin Moment as a Snapshot

If you want a single concrete picture of how violent this competition gets, Yavorovych cites bot expenditure during the TrumpCoin launch hitting 8,584 SOL — roughly $1.5 million — in a single hour. (Yavorovych)

Think about what that number represents. In one hour, the collective bot field paid that much trying to win one set of opportunities. One bot, or a small handful, walked away with the upside. Everyone else burned real capital and got the same return I'm getting — zero — but at considerably greater scale. The launch wasn't won by the bot with the best idea. It was won by the bot with the best path to the block at the right millisecond.

Reading that, I felt something I haven't felt much during this project: relief. Not because losing is fun, but because the loss isn't a personal failing of code or attention. It's a structural property of competing on saturated targets from the wrong side of an infrastructure moat.

The Three Stages I'm Now Recognizing

Looking back at my own iteration cycle, there's a pattern I think every newcomer goes through if they start from public data feeds:

Stage one: "I'll be faster." Tune the WebSocket subscription. Move regions. Trim parsing time. Each fix yields a few percent. Landing rate doesn't move because the floor isn't where you think it is.

Stage two: "I'll be smarter." Better cycle detection. More pools indexed. Tighter profit thresholds. The set of opportunities you can see grows, but the ones the competition wins are the same ones you're now seeing. Smarter detection on saturated targets is still saturated.

Stage three: realization. Everyone else has already done both of those things, at a higher floor of infrastructure than you have. The optimization itself isn't the bottleneck — the target is. Competing on the same routes against the same infrastructure tier, with worse tools, is a fixed game.

I'm in stage three now. The feeling isn't despair so much as it is a kind of conceptual reset. The question changes from "how do I make the bot faster" to "what is the bot even hunting."

The Saturation Signal Hiding in the Data

One data point from the Accelerate 2025 presentation by Ghostlogs crystallized this for me. The share of "blind" or wide sandwich attacks — speculative, lower-conviction ones — has grown from roughly 1% to 30% of all sandwich activity. (Solana Compass)

That's a saturation signal. When the high-confidence targets are exhausted because the top tier owns them, even well-resourced bots reach further down the quality curve, accepting more failed attempts in exchange for any opportunities that haven't been claimed. The premium routes — the ones I'm trying to compete on with a public WebSocket — are precisely the ones that are most contested.

Analysis reports that the top sandwich bot's daily bundle count peaked around 26,000 and later "sometimes fell below 4,000 bundles per day" as market activity cooled; that's the same signal in a different shape. (Solana Floor) Even the dominant operator's volume swings hard with overall flow. There isn't infinite room at the top. There's just a small number of seats, and they're taken.

What "Find a Different Deer" Actually Means

I keep coming back to a hunting analogy. If a hundred hunters are firing at the same deer simultaneously and only one shot lands, getting a better rifle changes nothing — ninety-nine other people have the same rifle. The way out isn't a better rifle. It's a different deer.

What that means for me, in practice, I'm still figuring out. Some directions feel obvious in the abstract: pools, tokens, or time windows that aren't already monitored by the top-tier infrastructure. Routes that are too long, too odd, or too small for the dominant operators to bother indexing. Opportunities defined by something other than "who saw the price change first."

None of that is a guarantee. Plenty of "different deer" turn out to be different for a reason — too illiquid, too risky, too rare to support a sustained operation. But it reframes the search. The bottleneck isn't my latency anymore. It's my targeting.

What Today Actually Changes

A few things shift for me as of right now, sitting with this zero:

One, I stop investing engineering time in shaving milliseconds off the public WebSocket path. The ceiling on that work is below the floor that wins races. It's not where my next bit of progress lives.

Two, I stop measuring my bot's quality by detection speed on contested routes. "Detected the opportunity" is not the same as "could have won it." If the opportunity was on a saturated pool, detection was never going to be the deciding variable. I need a different definition of "good bot."

Three, I take seriously that infrastructure category matters more than infrastructure tuning. There's an honest question I haven't answered for myself yet about whether the answer is to invest in a different access tier or to step sideways into opportunities where my current tier is fine. I don't have to decide today. But pretending the tier doesn't matter has stopped being viable.

And four — this is the part that's hardest to say cleanly — I have to be okay with the fact that the version of this bot I imagined when I started might not be the one that ever lands a trade. The shape of the market doesn't care about the version I imagined. It cares about whether what I'm pointing at is something only I can see.

Key Takeaways

• A public WebSocket subscription is a broadcast channel: every searcher on the same endpoint sees the same data at roughly the same time, leaving no information edge to exploit.
• Public WebSocket latency sits in the 100–300ms range per a published comparison, while validator-memory-tapping gRPC streams operate at sub-50ms — that's a category gap, not a tuning gap.
• Per analysis cited by Coinfeeds.ai, over 98% of arbitrage attempts on saturated routes fail; only the first successful arb in each race wins. A MEV report shows 75.7% of non-vote transactions were reverting at the April 2024 peak, largely from bot spam.
• Market concentration confirms the asymmetry: per Solana Floor and Extropy Academy, one sandwich bot accounts for 42% of all sandwich volume, and the top three combine for over 60%.
• Optimizing speed on saturated targets is a fixed game. The strategic move isn't a faster rifle; it's a different deer — opportunities the dominant infrastructure isn't already monitoring.