We Built On Two Chains From Day One — Adding Base Six Months Later Was a Weekend.
The Solana-vs-Ethereum debate is a trap for builders
You're building a crypto payments product in 2026. Which chain do you launch on?
Pick Solana, and a chunk of your users will tell you (often loudly, on Hacker News) that:
- The validator set is too centralized
- There's no mempool, so transactions silently drop during congestion
- Light clients can't cryptographically verify state
- "It's not even significantly cheaper than L2s anymore"
Pick Ethereum L1, and a different crowd tells you:
- L1 fees are insane for anything under $50
- Confirmation times are too slow for checkout UX
- Your users pay $5 in gas to send $20
Pick a single L2 (Base, Arbitrum, Optimism), and you trade L1's problems for new ones:
- Sequencer centralization
- Bridge risk
- Fragmented liquidity
- "What if Coinbase deprecates Base?" is a real question merchants ask. Yes, really.
Every chain has tradeoffs. Picking one means inheriting all of its tradeoffs and all of its critics.
So we picked the two that mattered most — and built the codebase so adding more later wouldn't require a rewrite.
What "two chains from day one" actually meant
We launched QBitFlow with two chains live in the first version of the product:
- Ethereum mainnet — for users who care about decentralization, censorship resistance, and the "real" Ethereum
- Solana — for users who want sub-second confirmations and fees measured in fractions of a cent
A merchant signs up, picks which chains and tokens to accept (USDC on both? ETH on L1? SOL on Solana?), and customers get a hosted checkout where they pick what to pay with. The smart contracts handle the rest. No bridges. No swaps. The merchant receives payment in the same token the customer paid with.
That's it. No ideological lock-in for the merchant or the customer.
The two-chain choice wasn't accidental. Ethereum and Solana represent the two largest stablecoin economies that don't share an execution model. Covering both meant we could plausibly serve almost any merchant who wanted crypto payments — and, more importantly, it forced the codebase to be honest about chain abstraction from the very first commit.
Then merchants asked for Base
Six months in, a clear pattern emerged in support tickets and sales calls:
"We want USDC. We want EVM-grade security so our users can pay from their existing Coinbase Smart Wallet. We want fees that don't kill micropayments. Do you have a plan for that?"
L1 Ethereum was too expensive for sub-$50 invoices. Solana was great on cost but a different ecosystem with its own wallet UX. Base — Coinbase's L2 — answered the merchant ask precisely: Ethereum's security model, Coinbase Smart Wallet onramp, USDC-native settlement, and fees in cents.
Adding Base took a weekend.
That sentence sounds like marketing, so let me show the work.
How a weekend was enough
Three reasons the Base addition was small instead of large.
1. Same EVM contracts, new deployment target
Base is an OP Stack L2 that runs the EVM. The smart contracts we'd already written, tested, and deployed on Ethereum mainnet were valid bytecode on Base. Adding Base on the contract side was a deployment script, a few configuration constants (chain ID, RPC endpoints, USDC contract address), and a deploy-and-verify run.
Solana would not have been a weekend. Solana would have been weeks at minimum — different language, different account model, different signature scheme, different audit story. We did Solana on day one specifically so we never had to do it as a "later" project. Base was the easy case because we'd already paid the hard cost.
2. The codebase was structured for new chains, not for two chains
This is the part most "we built multi-chain from day one" posts gloss over. There's a meaningful difference between:
- "We support Ethereum and Solana" — two specific chains hardcoded into your data model, your webhooks, your SDKs, your dashboard
- "We support multiple chains, currently Ethereum and Solana" — chain identifiers as first-class values, chain-specific behaviors isolated behind interfaces, no "if EVM else Solana" branches scattered through the business logic
We aimed for the second from commit one. It cost more upfront because every "just do it for Ethereum first" temptation had to be resisted in favor of an extra layer of abstraction. But the payoff was that adding a chain later wasn't a refactor. It was filling in implementations behind interfaces that already existed.
When Base showed up, the codebase asked: "What's the chain ID? What's the USDC contract address? Which RPC providers do we trust?" It didn't ask: "How do I express the concept of an L2 in a system that previously only knew about L1 and Solana?" That second question is the one that takes a quarter to answer in most multi-chain retrofits. We'd already answered it.
3. EVM means real code reuse, not just contract reuse
Beyond the smart contracts themselves, a lot of the off-chain code path for Base was identical to Ethereum:
- Transaction construction, signing, and submission
- Event log parsing
- Address validation
- Webhook payload schemas
- SDK methods
- Dashboard wallet configuration
The L2-specific differences exist (different gas dynamics, different finality assumptions, sequencer-specific edge cases) but they're additions on top of an existing EVM code path, not parallel implementations. Adding Base was something like a 10% incremental code surface — not 50%, not 100%.
The reason this worked is that we'd already spent the day-one cost of separating "EVM-shaped logic" from "Ethereum-mainnet-specific logic." On day one, you do that for nobody — there's only one EVM chain. Six months later, when an EVM L2 shows up, that distinction pays for itself in a weekend.
What it actually cost us upfront
Two-chains-from-day-one wasn't free. Here's where it actually hurt — honestly.
Two execution models doubled the cognitive load
Every architectural decision had to satisfy both EVM and Solana semantics. ECDSA on one side, Ed25519 on the other. Addresses on one side, program-derived addresses on the other. Gas on one side, compute units and priority fees on the other. RPC reliability quirks differ across providers and chains.
If we'd only done EVM, we'd have shipped faster. We'd also have written code that quietly assumed EVM forever, and Solana would have become a "v2 rewrite" project that never quite got prioritized.
RPC reliability eats more time than you think
Every chain has RPC providers. Every RPC provider has outages. With two chains, you have 2x the surface area for "the customer's transaction looked successful but the webhook never fired." With three, it's 3x — and Base in particular has its own L2-specific edge cases (sequencer hiccups, batch posting delays, withdrawal-window confusion in user support).
We run redundant RPC connections per chain (multiple providers + a public fallback) with health-check rotation. Months of work nobody asks about until a webhook is missing.
Fee abstraction is harder than it looks
EVM has gas. Solana has compute units and priority fees. L2s have gas plus L1 data costs that fluctuate independently of L2 gas. Showing a merchant "this will cost about $X to your customer" needs real-time data feeds for every ecosystem and graceful degradation when they disagree.
Testing surface multiplies
Unit tests, integration tests, fork tests, Solana localnet tests, L2 sequencer simulations — every PR has to pass on every chain. CI takes longer with each chain added. Local dev environment setup is more involved for new contributors.
Documentation gets thin in unexpected places
Most blog posts, tutorials, and Stack Overflow answers assume EVM L1. When a Solana-first dev hits an issue, or an L2-first dev hits an L1 assumption, they often need help we have to write ourselves.
On audits
A note on audits, because most multi-chain posts hand-wave this and we don't want to.
Our smart contracts are open-source on GitHub today. They have not been formally audited yet. Audits are real money — the kind of money that pencils out cleanly when you have meaningful merchant volume backing them, and feels expensive to commit pre-revenue when iteration speed still matters more than the audit certificate.
Our plan is straightforward: as merchant adoption grows and contract changes stabilize, we'll commission a formal audit across both EVM (covering Ethereum + Base — same bytecode, same audit) and Solana (separate review, different ecosystem). Doing both in the same window will be cheaper than doing them sequentially, and the EVM-on-EVM-L2 reuse means Base doesn't add meaningful audit cost beyond Ethereum.
Open-source-without-formal-audit isn't ideal. We're not pretending it is. It's the honest tradeoff for a small team optimizing for shipping over signaling. When the audit happens, we'll publish the report.
What we'd do differently
If we were starting QBitFlow today, we'd ship Ethereum + Solana and Base in v1, even if Base demand wasn't fully proven yet.
Three reasons:
- The L2-specific code paths are real, and getting them in while the codebase is small is even cheaper than the weekend it took us six months in. A few extra days on day one beats a weekend later.
- Base merchants converted faster than any other chain we've added. The Coinbase Smart Wallet onramp halved customer-side friction overnight. We left months of revenue on the table by waiting.
- The infra delta would have been negligible upfront — same redundant RPC setup, same monitoring, just one extra connection per layer.
The original "multi-chain from day one" thesis was right. Our application of it was just slightly too conservative on the L2 side.
When multi-chain from day one is the wrong call
I'm not pretending this is universal advice. Multi-chain from day one is the right call only if:
- Payments are your core product. If chains are just a deployment target for your dapp's logic, pick one and ship.
- Your users care about chain choice. If they'll use whatever you give them, multi-chain is wasted effort.
- You can afford the upfront discipline. If you're solo-bootstrapping with $5K of runway and three weeks before a demo, ship on one chain and prove demand first. The discipline is real and the discipline costs time.
For us, all three were true. QBitFlow is a payment rail. Our users (merchants) absolutely care about which chain their customers can pay on. We chose to take the upfront discipline cost so we'd never have to take the upgrade-rewrite cost.
What's next
We'll add more chains as merchant demand justifies them. Polygon, Optimism, Arbitrum, and a few non-EVM chains are on our roadmap. Each new EVM L2 should be in the same weekend-of-work range as Base was. Non-EVM chains will be more — but the day-one discipline of "chain identifiers as first-class values, no hardcoded execution-model assumptions" makes them additions rather than rewrites.
If you're building anything that touches payments and you're stuck on the "which chain" question, our answer is this: don't pick one. Architect for several from the start, even if you only ship two — and structure your code for adding chains, not for the chains you've shipped. The cost of being wrong about one chain is much smaller than the cost of being locked into one. The cost of architecting for "the chains we currently support" instead of "any chain we might add" is the difference between a weekend's work and a quarter's work, six months later.
QBitFlow is a non-custodial crypto payment rail for one-time payments, subscriptions, and marketplace fee splits — live on Ethereum, Base, and Solana. Smart contracts are open-source on GitHub. Try it →