The moment your backend signs and submits transactions on behalf of users, your business changes.

You are no longer just a trading platform or custodian.

You are an execution engine.

Most CEXs run that engine inefficiently.

Once you control signing, execution becomes a cost center, and most teams under-optimize it.

Centralized exchanges fall into a category that doesn’t get enough attention:

backend-signed execution systems.

These systems:

• Construct transactions server-side

• Control calldata and execution structure

• Pass gas costs to users (often with a buffer)

In a CEX, this includes:

• Withdrawals

• Deposit sweeping

• Hot ↔️ cold wallet rebalancing

• Internal settlement

• Cross-chain liquidity movement

There is no external signer. Everything is coordinated internally, signed by your infrastructure (or MPC provider), and executed at your expense.

Which means:

Execution inefficiency directly impacts both margins and user experience.

Most exchanges optimize for:

• Volume

• Liquidity

• Fees

• Latency

But under the hood, they run a high-throughput execution pipeline.

• One withdrawal = one transaction

• Repeated logic with fixed overhead per user

• The same contract calls encoded over and over

• No aggregation or batching across users

• Identical transfers executed independently

• Systems built for correctness, not efficiency

At small scale, costs are negligible.

At large scale, they compound across millions of transactions.

Execution quietly becomes one of the largest unoptimized cost centers in a CEX.

Pattern:

• One request → one transaction

Opportunity:

• Batch across users

• Share execution overhead

Pattern:

• Individual sweeps from deposit addresses

Opportunity:

• Aggregate transfers

• Reduce repeated contract calls

Pattern:

• Independent transfers across wallets and assets

Opportunity:

• Combine flows

• Optimize timing and batching

Even mostly offchain systems still:

• Move funds

• Reconcile balances

Opportunity:

• Treat internal operations as batchable units

• Reduce routine execution cost

Spire Labs builds DA Builder, a transaction aggregation layer for Ethereum.

It sits between your backend and the chain, combining multiple transactions into a single optimized execution.

DA Builder:

• Combines multiple transactions into a single onchain transaction

• Reduces redundant overhead and execution costs

• Shares calldata across transactions

• Lowers gas and calldata costs

• Improves inclusion via higher-value bundled transactions

• Adds built-in MEV and revert protection

Framed simply:

Execution infrastructure for teams that already own transaction flow

No changes to:

• UX

• Product logic

• Core systems

Just more efficient execution.

Lower gas per action directly improves unit economics.

Cheaper execution enables lower fees and better pricing.

Batching reduces cost per transaction as volume grows.

If your backend signs transactions, execution is your responsibility.

Most CEXs today:

• Treat execution as plumbing

• Accept default patterns

• Ignore aggregation

That won’t hold.

Execution optimization will become standard infrastructure, like CDNs in Web2.

And exchanges that adopt it early will have a structural advantage:

• Lower costs

• Better pricing

• More scalable systems

Because ultimately:

If you control signing, you control execution.

And execution is worth optimizing.