Contracts are the easy part.

We build and run the rest of it. The site, the backend, the DEX, the indexer, the database, and the desk that answers when it breaks. Under load, on launch day.

2M+wallets registered

$2B+moved through our systems

600+contracts in production

0funds lost to an exploit

The whole machine

one system, one team

This is the shape of it. We build every box and we carry the pager for all of them.

       launch traffic                                on-call
                │                                        ▲
                │                                        │
   ┌────────────▼─────────────┐             ┌────────────┴────────────┐
   │ edge · cdn · rate limits │             │ metrics · tracing       │
   └────────────┬─────────────┘             │ alerts under 30s        │
                │                           └─────────────────────────┘
   ┌────────────▼─────────────┐  sessions   ┌─────────────────────────┐
   │ web · sign-up · wallet   │────────────▶│ cache · hot state       │
   └────────────┬─────────────┘             └─────────────────────────┘
                │
   ┌────────────▼─────────────┐  writes     ┌─────────────────────────┐
   │ api · referral tree      │────────────▶│ database · replicated   │
   └────────────┬─────────────┘             └─────────────────────────┘
                │ jobs
   ┌────────────▼─────────────┐
   │ queue · workers          │
   └────────────┬─────────────┘
                │
   ┌────────────▼─────────────┐    events   ┌─────────────────────────┐
   │ indexer · replay         │◀────────────│ nodes · ours, not rented │
   │ reorg-safe, rebuildable  │             └────────────┴────────────┘
   └──────────────────────────┘                          ▲
                                                         │ logs
                                            ┌────────────┬────────────┐
                                            │ contracts · dex         │
                                            │ live on mainnet         │
                                            └─────────────────────────┘

the diagram scrolls sideways

edge, web	Sign-up and wallet flows built for a stampede rather than a demo. Every screen has a degraded mode.
api, cache	Sessions, referral trees, balances. The write path stays consistent while the network does not.
queue, workers	Everything slow moved off the request. Retries that are safe to run twice, because they will be.
database	Replicas, hot paths, and migrations performed while people are online. Backups proven by restoring them.
nodes, indexer	Nodes we run ourselves, so we are not rate limited on the day it matters. Chain state rebuildable from the log at any block.
contracts, dex	Solidity that has to be right the first time, with upgrade paths that do not brick live state.
metrics, on-call	None of these boxes fails alone. Alerts fire while it is still recoverable, not in the morning.

Work

three platforms at this scale, one shown

Names withheld. If someone sent you here, ask them and they will tell you.

DeFi and GameFi platform

A rewards and bonus engine, an NFT marketplace, our own DEX, and a game layer on top of it. We built and operated the entire technical side: contracts, exchange, front end, backend, databases, indexer, and the tooling the support desk ran on.

2,000,000+ registrations 3+ years built and operated 25 engineers at peak Polygon, Ethereum

Two further platforms of the same shape

Same problem, same scale: reward mechanics, a marketplace, an exchange and a game layer, each built and then run by us rather than handed over and forgotten.

In progress · a game on TON

Outside the EVM, on a different virtual machine and a different execution model. We took it because the interesting part of this work is never the language.

a monitor we ship with every deployment, simplified

# supply must never exceed what the mint path can produce
invariant total_supply_matches_mint_log:
    token.totalSupply() == sum(MintEvent.amount) - sum(BurnEvent.amount)

check   every block, max 1 block behind head
on fail page on-call, freeze the payout worker, do not auto-heal

If you have run one of these, you already know

Launch days where registrations arrive faster than blocks.
Referral trees that have to stay consistent while the network is congested.
Millions of wallets, and the support desk that comes with them.
The site, the contracts, the DEX, the indexer and the database are one system. They fail together.

What we turn down. Work where the launch date is fixed before the design is, and rescue jobs where nobody is allowed to touch the contracts. We say so on the first call rather than three months in.

Tell us what you are building.

This page is a calling card, not a funnel. If someone sent you here, you already know what we do. Describe the machine, and we will tell you plainly whether it is ours to build.

hi@bl3ndr.io