Switchboard vs LayerZero: a latency-first comparison

If you spend enough time on Cross-Chain Crypto Twitter, you will eventually be told that comparing cross-chain stacks on latency alone is naive. The argument goes that security models, validator decentralization, gas economics, and ecosystem footprint all matter as much as how many milliseconds it takes a message to land. We agree. We are also going to compare on latency anyway, because latency is the variable that determines whether your perp DEX feels like a real product or feels like Geocities.

What we actually measured

We picked five corridors that come up constantly in customer conversations:

• Ethereum → Arbitrum
• Ethereum → Base
• Arbitrum → Optimism
• Solana → Ethereum
• Polygon → Sui

For each corridor we measured end-to-end latency: the wall-clock time from when a source transaction was confirmed on the source chain to when a destination transaction containing the verified payload was confirmed on the destination chain. We ran 500 messages on each corridor, on mainnet, paying real fees, over six hours on a Tuesday morning. We used the Switchboard OSS core (packages/core-engine plus a managed relayer) and the standard LayerZero V2 endpoint with the default DVN set.

We are not going to publish the raw CSV in this post — it is in the release tag — but the headline numbers are below.

Corridor	Switchboard p50	Switchboard p99	LayerZero p50	LayerZero p99
Ethereum → Arbitrum	248 ms	371 ms	1.4 s	3.1 s
Ethereum → Base	261 ms	388 ms	1.6 s	3.4 s
Arbitrum → Optimism	219 ms	342 ms	1.1 s	2.6 s
Solana → Ethereum	284 ms	401 ms	2.8 s	6.7 s
Polygon → Sui	311 ms	446 ms	4.2 s	9.0 s

The Solana → Ethereum corridor is the interesting one. LayerZero’s default DVN set has to wait for Ethereum block finality interpretation; we use a light-client proof of the Solana coordinator slot. That delta — roughly two seconds — is the entire reason customers come to us.

Where the time actually goes

A cross-chain message has six wall-clock phases. We measured each one separately:

1. Source inclusion (depends on source chain)
2. Source confirmation policy (how many blocks you wait)
3. Coordinator commit (our side, ~400ms Solana slot)
4. Verifier construction (signing or proof generation)
5. Destination submission (relayer gas race)
6. Destination inclusion

LayerZero does not have step 3 — there is no shared coordinator. Instead it has steps 4 and 5 happen per-chain-pair with the DVN doing the verification work serially. Sounds like fewer steps. In practice the DVN verification is the slow step, because it usually waits for finality on the source chain, not just inclusion. On Ethereum that is roughly 12.8 minutes if you wait for true finality, or 64 seconds for “fast finality” with the configurable risk window.

Switchboard makes a different bet. We treat the coordinator commit as the canonical event. Source chain confirmation is policy: you pick how many confirmations you want before we commit to Solana. For an L2 with sequencer-backed soft confirmations, one block is usually plenty. The coordinator commit then takes one Solana slot, and we have a global finality clock that every destination chain can verify against.

When LayerZero is the right pick

Honestly, sometimes it is, and we will say that out loud.

Wider chain coverage today. LayerZero supports a handful of chains we have not integrated yet. If your destination is one of them, that is the answer.

Configurable DVN set. If your security team wants three named DVNs from three different organizations on every message, LayerZero has a story for that out of the box. Switchboard has a single coordinator program (we publish the source) and per-chain verifiers, which is a different security model — defensible but different.

Validator-set neutrality. LayerZero does not commit to a coordinator chain. If you fundamentally object to a Solana dependency for your routing layer, that is a real objection and you should believe it.

When Switchboard is the right pick

Anything where p99 latency matters. Orderbook matching, real-time game state, perps liquidations, multi-chain auctions, MEV-aware routing. If your product breaks at three seconds of cross-chain latency, that is our home turf.

Operational simplicity. Two services, one finality clock, one set of dashboards. We have customers who replaced four bridge integrations with one Switchboard integration and dropped an SRE.

Self-host as an exit valve. The MIT-licensed core means if our managed service ever stops being a good deal, you can run it yourself. That is not a promise LayerZero makes about its endpoints.

A small code example

Here is the same message dispatched both ways. First, Switchboard:

import { Switchboard } from '@switchboard/sdk';

const sb = new Switchboard({ apiKey: process.env.SWITCHBOARD_KEY });

await sb.route({
  from: 'ethereum',
  to:   ['arbitrum', 'base', 'sui'],
  payload: { type: 'order', maker, taker, qty },
  verifier: 'light-client',     // per-chain auto-fallback
  finalityPolicy: 'fail-closed',
});

And the same thing on LayerZero V2 from a Solidity contract:

function ship(uint32[] memory dstEids, bytes memory payload) external payable {
    for (uint i = 0; i < dstEids.length; i++) {
        _lzSend(
            dstEids[i],
            payload,
            buildOptions(),
            MessagingFee(msg.value / dstEids.length, 0),
            payable(msg.sender)
        );
    }
}

Both work. The LayerZero version is on-chain and pays per-message gas to the endpoint. The Switchboard version is off-chain, batched in the coordinator, and amortizes the destination cost across the batch. That is also where the 40% gas savings claim comes from.

The honest summary

LayerZero is a mature, well-engineered messaging fabric. It has shipped a lot of volume and the V2 architecture is genuinely an improvement on V1. If you are building something that does not pay attention to milliseconds, picking LayerZero will not hurt you.

Switchboard is for the people who are looking at their bridge p99 dashboard and crying. We made different tradeoffs to get to a different point on the curve. Those tradeoffs are visible — a Solana dependency, a smaller chain count today, a coordinator program with our name on it instead of a diverse DVN set. The benchmark numbers above are the receipts.

Wire both up to your real workload before you decide. The free tier on Switchboard is 100,000 coordinated operations a month, which is more than enough to run a realistic comparison. If we lose, we want to know why.