Flux, modularity, and the real cost of scaling blockchains — with Davy

For many Web3 builders, scalability is the holy grail. But what if scaling isn’t just about throughput or TPS — but about developer experience, modularity, and resilience?

In this episode, I sat down with Davy from Flux, an open modular execution layer that lets developers build rollups with built-in settlement, sequencers, and composability — without reinventing the wheel. We talk about what it takes to actually scale Web3, why the monolithic chain thesis is collapsing, and how Flux is offering a more composable alternative.

Beyond rollup kits: Why dev experience matters

Flux isn’t trying to build the next rollup-as-a-service product. Instead, they’re offering infrastructure primitives — a stack of tools and APIs — that lets devs spin up rollups with minimal overhead.

Think: integrated data availability, sequencers, settlement, and shared bridging — all under one roof.

This is critical because most developers don’t want to spend weeks figuring out how to wire together Celestia, EigenLayer, Arbitrum Orbit, and third-party sequencers. Flux abstracts that complexity and makes launching new rollups as easy as deploying to Vercel.

And importantly, developers can retain sovereignty — Flux isn't a chain; it’s a modular layer that plugs into your chain.

How Flux handles settlement and composability

One of the biggest pain points in today’s multi-chain environment is fragmented liquidity and poor interoperability. Flux tackles this by offering native settlement across rollups that build with their stack.

This means:

• Inter-rollup composability without relying on third-party bridges.
• Cross-rollup messaging and interoperability with atomic guarantees.
• Built-in support for shared sequencers and fraud proofs.

As Davy explains, this makes Flux a kind of "shared security + shared execution + shared settlement" zone — while still giving each rollup its own logic, purpose, and autonomy.

Incentive alignment and the Flux token

Flux plans to align incentives with developers and users through its native token. But unlike speculative models, the tokenomics are designed around utility and alignment:

• Rollup developers pay fees to Flux infra providers.
• Flux validators and sequencer operators earn those fees.
• Community members who contribute infra or tooling can stake and participate in governance.

It’s a model that’s designed to avoid rent-seeking while keeping core contributors and ecosystem participants aligned.

Why now? And what comes next

The modular thesis is maturing. Rollups are here to stay. But what we’re missing, Davy argues, is shared execution layers that remove bottlenecks while preserving flexibility.

Flux is betting on the idea that the future isn’t a thousand rollups fighting for liquidity — but rather a composable execution mesh where teams can deploy fast and interoperate natively.

The team is launching devnet soon, and looking for early partners who want to build rollups that don't just scale — but talk to each other from day one.

If you’re a developer building modular infra or need a custom execution environment, Flux might be your next stack.

More at: https://runonflux.com/