The NFT marketplace pattern has settled into something fairly standard, which means the interesting decisions are no longer about architecture. They are about royalties, custody and where liquidity actually comes from.
Off-chain orders, on-chain settlement
Listing an item should cost nothing, because most listings never sell.
So a listing is a signed order held off-chain: the seller signs a message stating they will transfer token X for price Y until time Z. No transaction, no gas, and cancelling is free.
When a buyer accepts, the signed order is submitted on-chain and the contract verifies the signature, transfers the token, and splits payment.
This is now the default because the alternative — an on-chain transaction per listing — makes an active marketplace prohibitively expensive to use.
Never take custody
Custodial escrow at listing time is easier to build and worse in every way that matters.
Users dislike surrendering assets to list them. More importantly, a contract holding thousands of valuable tokens is a concentrated target, and the history of this category is unkind to concentrated targets.
The approval pattern is better: the seller grants the marketplace contract permission to move that specific token if a valid order executes. The asset stays in their wallet until the moment it sells.
Approval scope matters. Blanket approvals across an entire collection are convenient and have been the mechanism behind a significant amount of theft. Scope narrowly, and surface clearly to users what they are approving.
Royalties, honestly
This is the most contested area in the category and the honest position is uncomfortable.
Marketplace-level royalties are voluntary. A marketplace chooses to pay them. When competing marketplaces made them optional to attract volume, creator royalty income collapsed, because the market routes to the cheapest venue regardless of what anyone intended.
The only durable enforcement is at the collection contract: transfers that do not route payment correctly are blocked. This has to be built in at deployment and cannot be added afterwards.
That approach has real costs — it restricts where the token can trade and it interacts awkwardly with lending and other DeFi composability. It is a genuine trade-off, and a creator deciding it should be told plainly rather than promised royalties that a marketplace may decline to honour.
The indexing layer is most of the work
Underestimated in every NFT project.
To show a collection you need current ownership of every token, all active listings across contracts, historical sales, trait data, rarity computation, and metadata resolved from whatever storage each collection chose.
That means indexing on-chain events continuously, handling reorgs, resolving metadata that may be on IPFS, on a server, or missing entirely, and serving it fast enough that browsing feels instant.
The trading contracts are a fraction of the codebase. The indexer is most of it, and it is where the operational burden lives afterwards.
Liquidity and aggregation
A new marketplace faces the cold-start problem acutely: no listings means no buyers, no buyers means no sellers.
The practical answers are aggregating listings from elsewhere so the venue is useful immediately, focusing narrowly on a category or a chain where you can be the best rather than the biggest, or building creator tooling good enough that collections launch with you natively.
Competing head-on with established general marketplaces on breadth is the approach that reliably fails.
The details that determine trust
- Fee transparency. Show the breakdown — marketplace, royalty, gas — before confirmation, not after.
- Failed transaction handling. Gas spent on a transaction that reverted needs explaining clearly.
- Stolen asset policy. Decide before you need it, publish it, apply it consistently.
- Metadata that does not vanish. Pin what you can, cache what you cannot, and degrade gracefully when a collection’s storage disappears.
Before mainnet
Marketplace contracts hold approvals across thousands of users, which makes them a high-value target even without holding assets directly.
Minimal custom code on audited standards, two independent third-party audits, and a bug bounty live before volume arrives. We coordinate those firms rather than auditing our own work.
Common questions
How does an NFT marketplace work?
Sellers list an item with a price, which is recorded as a signed order rather than an on-chain transaction to keep listing free. Buyers accept an order, which executes the trade on-chain - transferring the token and splitting payment between seller, marketplace and royalty recipient. The off-chain order book with on-chain settlement is the standard pattern because it makes listing and cancelling cost nothing.
Can NFT royalties be enforced?
Only where the token contract itself enforces them. Marketplace-level royalty payment is voluntary, which is why royalty income collapsed when marketplaces began treating it as optional. Enforcement at the contract level - blocking transfers that do not route payment correctly - is the only durable mechanism, and it has to be built into the collection contract at deployment.
What is the difference between a marketplace and an aggregator?
A marketplace holds its own order book and settles trades against it. An aggregator reads listings from several marketplaces and routes a buyer to the cheapest, taking a fee for the routing. Aggregators win on price discovery and depend entirely on marketplaces existing; marketplaces win on listing relationships and creator tools.
How do you handle custody on an NFT marketplace?
Non-custodially, through approvals. The seller grants the marketplace contract permission to transfer that specific token if a valid order is filled, and the token stays in their wallet until it sells. Escrow designs that take custody at listing are simpler to build and worse for users, and they concentrate risk in a contract holding thousands of assets.
Does Corum8 build NFT marketplaces?
Yes. We build marketplace contracts and order books, royalty enforcement at the collection level, minting infrastructure, the indexing layer and front end, and creator tooling. We coordinate independent third-party audits before mainnet.
