Customizing Your Appchain (L1)

Kamil Jakub Natil
Jan 16
4 min read

Full Sovereignty Without the Infrastructure Burden

TLDR: Tanssi lets teams launch a sovereign, EVM-compatible appchain in minutes using EVM or Substrate templates, then customize runtime logic, gas models, governance, and upgrades over time, without running or maintaining L1 infrastructure.

Tanssi lets teams launch a sovereign, EVM-compatible appchain in minutes using EVM or Substrate templates, then customize runtime logic, gas models, governance, and upgrades over time, without running or maintaining L1 infrastructure.

Smart contracts are powerful, until they are not enough.

Teams move to appchains (purpose-built L1 blockchains) when they need control at the protocol level: custom execution logic, flexible fee models, governance that aligns with their product, or the predictable performance that shared platforms cannot offer.

The challenge is that sovereignty traditionally comes with a cost. Launching a sovereign chain does not stop at writing a runtime. It also means owning block production, validator coordination, RPC reliability, indexing, upgrades, and the long tail of day-two operations.

With Tanssi, teams can deploy a production-ready L1 in minutes using EVM or Substrate templates, then customize runtime logic, gas models, governance, and upgrades over time, without running their own chain infrastructure.

This article walks through the real customization surface of a Tanssi-powered L1, focusing on practical patterns teams use when building protocols across DeFi, RWAs, and consumer applications.

What a Tanssi-powered L1 looks like

Tanssi is designed to separate protocol design from chain operations.

You stay fully sovereign over how your L1 behaves. Tanssi orchestrates the infrastructure and coordination required to run it reliably in production.

At a high level

You customize the protocol layer
Tanssi orchestrates the operational layer

Simplified diagram showing the key responsibilities in the separation of protocol design and chain operations.

This separation allows teams to launch and iterate on L1s without building or maintaining a dedicated chain operations team.

What you (builder) customize

As an L1 or appchain builder, you control all protocol-level decisions, including:

Runtime logic Use an EVM-compatible runtime for fast deployment, or build a fully custom Substrate runtime with domain-specific logic.

Execution rules and primitives Define how transactions are validated, how state transitions occur, and which rules are enforced at the protocol level.

Gas models and fees Choose the native gas token, subsidize transactions, enable gasless flows, or design application-specific fee logic.

Tokenomics and incentives Define genesis distribution, minting and burn mechanics, inflation rules, and reward flows.

Governance and upgrades

Decide who can propose and approve changes, how upgrades are executed, and how control evolves.

In short, everything that defines how your chain behaves is under your control.

What Tanssi orchestrates

Tanssi handles the components that are operationally complex and costly to manage in-house:

Decentralized block production and coordination Block production and sequencing are handled without requiring teams to recruit or manage operators.

Network orchestration Peer discovery, networking, and liveness are coordinated at the protocol level.

RPC access and reliability Public endpoints are provisioned so developers and users can interact with the chain from day one.

Indexing, explorers, and observability Core tooling for development, monitoring, and debugging is available without custom setup.

Upgrade propagation and synchronization Runtime upgrades are applied without manual coordination across node operators.

This allows teams to focus on building the protocol itself rather than the infrastructure required to keep it running.

Why L1s instead of L2s?

L2s are a strong choice when protocol-level control is not a priority.

However, some requirements are difficult to express on L2s:

Custom execution logic beyond smart contracts
Application-specific gas and fee markets
Protocol-level governance and upgrade rules
Predictable performance without shared execution constraints

For teams building differentiated protocols, these constraints often appear early. Appchains offer full control at the protocol level, while Tanssi removes the traditional operational burden associated with running an L1.

Runtime customization

At the core of every L1 is its runtime. This is where execution rules live and where protocol-level behavior is defined.

Tanssi supports two complementary approaches, depending on the level of control your protocol requires.

EVM-compatible runtime for fast launches

Tanssi provides an EVM-compatible runtime template that allows teams to deploy smart contracts immediately.

This option works best when:

You already have Solidity contracts,
Most logic lives at the contract layer,
Speed to market is a priority.

Teams still benefit from sovereign execution, custom gas models, governance control, and forkless upgrades, without rebuilding their stack.

Custom Substrate runtime for protocol-level logic

When smart contracts are not enough, Tanssi supports fully custom runtimes built with Substrate.

This allows teams to:

introduce domain-specific primitives,
enforce rules directly at the protocol level,
define native behavior shared across the entire chain.

This approach is common when execution rules must be consistent, enforceable, and difficult to bypass.

Typical pattern: Instead of duplicating permission or compliance logic across multiple contracts, teams move these rules into the runtime, reducing complexity and long-term maintenance.

Gas models and tokenomics

On Tanssi-powered L1s, gas is not a fixed design choice.

Teams can:

choose the native gas token,
subsidize or sponsor transactions,
enable gasless flows for specific actions,
define application-specific fee logic.

This flexibility allows teams to design user experiences that feel closer to Web2, while still operating on a sovereign blockchain.

Tokenomics are equally configurable. Teams control:

genesis distribution,
minting and burn mechanics,
inflation rules,
reward flows for users, builders, and operators.

Typical pattern: Consumer-facing apps often subsidize gas for onboarding while capturing value elsewhere in the protocol.

Governance that evolves with your protocol

Governance defines how a protocol changes over time.

L1s launched on Tanssi support a wide range of governance models, allowing teams to evolve control as the protocol matures.

A common progression:

Early stage: small council or multisig for fast iteration
Growth stage: shared or delegated governance
Mature stage: open, on-chain governance

This allows teams to move quickly early on without locking themselves into a governance model that no longer fits later.

Forkless upgrades and iteration speed

Upgrading an L1 has traditionally required coordination, downtime risk, and careful timing.

Tanssi-powered L1s support forkless runtime upgrades. When a new runtime is dispatched, it takes effect without manual coordination across node operators.

This enables teams to:

ship improvements faster,
patch issues safely,
iterate without interrupting users.

Upgrades feel closer to shipping software than managing a network event.

Common customization recipes

The diagram shows the common L1 customization options by industry for the building team.

Conclusion

Launching an L1 unlocks protocol sovereignty, but that sovereignty has historically come with heavy operational overhead. Tanssi separates protocol design from chain operations.

With a Tanssi-powered L1, teams get: