- What it is: Building an NFT marketplace on Solana means deploying Rust-based on-chain programs (using the Anchor framework) that handle minting, listing, buying, and royalties — integrated with a Web2 backend for metadata, search, and user accounts.
- Core stack: Anchor framework + Metaplex Token Metadata Standard for smart contracts; Phantom/Solflare via Wallet Adapter for frontend auth; IPFS or Arweave for off-chain NFT metadata; React or Next.js for UI.
- Minting cost advantage: Minting an NFT on Solana costs ~$0.0004 vs. $18–$150 on Ethereum — a difference that directly impacts marketplace UX and creator adoption.
- Compressed NFTs (cNFTs): Solana's ZK Compression allows minting up to 1 million NFTs for under $110 total — enabling use cases like mass ticketing or loyalty programs that are economically impossible on other chains.
- Development timeline: A production-ready Solana NFT marketplace takes 3–5 months for a full team. MVP with core buy/sell/mint flows — 6–8 weeks.
- Cost range: $40,000–$150,000+ depending on feature scope, mobile apps, and custom smart contract complexity.
Solana is a high-throughput blockchain designed for smart contracts, dApps, and NFTs in a decentralized environment. Despite launching in 2020, it has become one of Ethereum's most credible alternatives — not because of hype, but because of measurable technical advantages that matter specifically for NFT marketplace economics: near-zero minting fees, sub-second finality, and a growing ecosystem of purpose-built developer tools. This guide covers the architecture, development process, real-world technical decisions, and cost breakdown for building a production-grade NFT marketplace on Solana.
Why Solana for NFT Marketplace Development
65,000+ TPS and What It Means for Marketplace UX
Solana's architecture sustains up to 65,000 TPS under average load and has demonstrated 190,000 TPS in controlled throughput tests. The Solana core team projects capacity scaling toward 700,000 TPS as validator hardware improves. For an NFT marketplace, this matters in concrete ways: a popular NFT drop won't clog the network with unconfirmed transactions, minting queues don't form, and bidding in live auctions happens with sub-second feedback rather than the 30–60 second waits common on Ethereum during congestion events.
Minting Cost: $0.0004 vs. $18–$150 on Ethereum
Transaction fees on Solana average $0.00025. Minting an NFT — which involves initializing multiple on-chain accounts (mint account, metadata account, token account) — costs approximately $0.0004 per NFT. On Ethereum, the same operation costs $18 to $150 depending on network congestion. In May 2022, Ethereum transaction fees peaked at $196. That cost structure makes Ethereum economically hostile to any NFT use case involving high volumes, low-value items, or creator-first economics.
Compressed NFTs: 1 Million Mints for Under $110
Solana's ZK Compression (launched by Solana Labs as a standard protocol update) introduces compressed NFTs — cNFTs — that use zero-knowledge proofs and concurrent Merkle trees to store NFT ownership state off-chain while keeping proofs verifiable on-chain. The economics are dramatic: minting 1 million cNFTs costs approximately $110 total, compared to roughly $400,000 for the same volume as standard Metaplex NFTs, and several million dollars on Ethereum.
Gulf Stream: No Mempool, Predictable Confirmation
Solana doesn't use a traditional mempool. Instead, it uses the Gulf Stream protocol, which forwards unconfirmed transactions to the next expected validator before the current block closes. This means transactions queue at the validator level, not in a public waiting room where users can front-run each other with higher fees. For NFT marketplace developers, this eliminates an entire class of UX problems: no "stuck" transactions, no gas war mechanics during NFT drops, and no need to implement dynamic fee estimation UI for users.
Rust + Anchor: Easier to Build, Easier to Hire
Solana smart contracts (called "programs") are written in Rust using the Anchor framework — a higher-level abstraction that handles account deserialization, access control, and error management that developers would otherwise write manually. Rust ranks consistently higher than Solidity in developer satisfaction surveys and has a broader talent pool. Anchor further reduces onboarding time for developers new to Solana. The LLVM-based toolchain also supports migration of smart contract logic from WASM-compatible networks (Polkadot, EOS) with less rewriting than Ethereum requires.
| Parameter | Solana | Ethereum | BNB Chain |
|---|---|---|---|
| TPS (avg) | 65,000 | ~15–30 | ~300 |
| NFT Mint Cost | ~$0.0004 | $18–$150 | $0.20–$2 |
| cNFT (1M mints) | ~$110 | ~$5M+ | ~$200,000 |
| Smart contract language | Rust (Anchor) | Solidity | Solidity |
| Finality | ~400ms | ~12s (PoS) | ~3s |
| Mempool model | Gulf Stream (none) | Classic mempool | Classic mempool |
Solana NFT Marketplace Landscape: Who You're Building Against
The dominant Solana NFT marketplaces as of 2025–2026 are Magic Eden (multi-chain, largest by volume), Tensor (orderbook-based, traders-first UX), and Exchange.Art (curated, fine art focus). Understanding their architectures informs your own product decisions:
- Magic Eden uses an aggregator model — it pulls listings from multiple protocols — and built its own listing program separate from Metaplex's default auction house.
- Tensor pioneered compressed NFT support at scale and introduced a CLOB (central limit order book) model for NFTs, enabling more sophisticated trading mechanics.
- Exchange.Art demonstrates the viability of niche positioning: by focusing on 1/1 digital art with an artist-first royalty model, it competes on creator trust rather than volume.
If you're entering this market, a general-purpose marketplace competing directly with Magic Eden is the hardest possible entry point. Niche positioning — a vertical (gaming, music, real estate tokenization, event tickets) or a mechanics differentiation (cNFT-native, royalty-enforced, DAO-governed) — gives you a defensible starting position.
How to Build a Solana NFT Marketplace: Step-by-Step
Step 1: Define Your Niche and Token Model
Before writing a line of code, the most important architectural decision is what kind of NFT your platform will handle — because this determines your smart contract structure, metadata schema, and compliance requirements.
Standard PFP / Art / Collectibles. The default use case. Uses Metaplex Token Metadata standard, standard auction/listing programs. Well-understood architecture, competitive market.
Gaming items and in-game assets. High-volume, low-cost minting makes Solana a natural fit. cNFTs are increasingly used for in-game item issuance. Key technical differentiator: your marketplace needs to handle NFTs with mutable on-chain attributes (a sword that gains experience, a character whose stats change). Metaplex's P2E game ecosystem tooling supports this.
Real estate tokenization. This is architecturally the most complex niche. NFTs represent fractional ownership of physical assets, which means your smart contract must handle regulatory compliance at the token level: KYC/AML checks on wallet addresses before allowing transfer, jurisdiction-based transfer restrictions, and a profit-distribution mechanism (rental income → proportional SOL or USDC distribution to token holders). In one of our real estate NFT marketplace projects, the admin panel included a dedicated module where the platform operator inputs rental income for each property, and the smart contract program distributes it automatically across all token holders based on their stake — down to the on-chain calculation of proportional USDC amounts per wallet.
Event ticketing. NFT tickets solve real industry problems: scalping, counterfeit tickets, and lack of resale revenue for organizers. Technical requirement: your minting flow must support physical-to-digital linking (QR codes on physical tickets that trigger on-chain minting), and your transfer program must enforce maximum resale price or royalty on secondary sales. The same physical-to-digital binding principle is central to real-world asset tokenization — where a QR or NFC tag on a physical deed maps to an on-chain ownership record.
Music and creator royalties. Solana's royalty infrastructure via Metaplex supports programmable royalties — but enforcement on secondary sales requires your marketplace's listing program to validate royalty payments as part of the buy transaction. Platforms that skip this validation are where creator royalties get bypassed. If creator-first economics are your value proposition, build royalty enforcement into the protocol layer, not as a UI checkbox. The music NFT marketplace segment is particularly sensitive to royalty model trust — creators choose platforms that guarantee their earnings on resale.
Step 2: Choose Your Monetization Model
There are five standard monetization models for NFT marketplaces. The right choice depends on your niche, expected volume, and creator vs. collector audience ratio:
| Model | Mechanics | Best for | Typical rate |
|---|---|---|---|
| Transaction fee | % of each sale deducted at smart contract level | High-volume general marketplaces | 1–2.5% |
| Listing fee | Fixed fee per NFT listed, regardless of sale | Curated marketplaces with high-value items | $1–$10 flat |
| Minting fee | Fee for using the platform's mint interface | Launchpad-style platforms | $5–$50 per collection |
| Subscription | Monthly/annual access fee for creators | Platforms with exclusive creator tools | $15–$100/month |
| Freemium | Basic listing free; premium placement/features paid | Early-stage growth-focused platforms | Varies |
One architecture note: implement your fee logic inside the smart contract, not in the frontend or backend. A marketplace that collects fees only at the UI layer can be bypassed by users interacting directly with the program. On-chain fee enforcement — where the buy instruction validates that the marketplace fee account received its share before completing the transfer — is the only tamper-proof approach. Our NFT marketplace development team applies this model across all marketplace builds by default.
Step 3: Define Core Features
Here are the features that define a production-ready Solana NFT marketplace:
NFT Showcase / Discovery. The main listing page must display NFTs with real-time pricing, rarity rankings, collection-level stats (floor price, 24h volume, number of unique holders), and filtering by traits. This requires an off-chain indexing service — you cannot query all of this data from the chain on every page load. Build a dedicated indexer that listens to your program's transactions via Solana's WebSocket subscription API and writes structured data to PostgreSQL.
Wallet Integration. Solana wallet integration is standardized through the Wallet Adapter library, which supports Phantom, Solflare, Backpack, Ledger, and others through a single interface. Your frontend calls @solana/wallet-adapter-react — this handles wallet detection, connection state, and transaction signing without you writing wallet-specific code. Never build wallet integrations individually; always use the adapter.
NFT Minting. The minting UI must abstract away all blockchain complexity. A user selects a file, fills metadata fields, pays the minting fee, and receives their NFT. Under the hood, this involves: uploading the asset to IPFS or Arweave, constructing the metadata JSON per Metaplex standard, calling the CreateMetadataAccountV3 instruction, and initializing the token account. For collections, you additionally need the collection NFT and the VerifyCollection instruction. If your platform is launching creator collections at scale (drops, allowlists, public mints), consider building or integrating a dedicated NFT launchpad module — it handles allowlist mechanics, phased mint windows, and bot protection that a basic mint interface doesn't cover.
Listing and Auction System. Your marketplace program must support fixed-price listings and English auctions (ascending bids with a time limit). Each listing is an on-chain PDA that escrows the NFT until sale or cancellation. For auctions, the program tracks the highest bid and automatically refunds the previous bidder when a higher bid arrives. Implement a buffer period (e.g., 5-minute extension if a bid arrives in the last 2 minutes) to prevent bid sniping.
On-chain Royalties. Implement royalty enforcement at the program level using Metaplex's Programmable NFTs (pNFTs) standard if creator royalties are a core value proposition. pNFTs enforce royalties by requiring any transfer to route through authorized programs — a marketplace that isn't authorized simply cannot move the NFT.
NFT Royalty Program. Allow creators to set royalty percentage (1–10%) at mint time, stored in the Metaplex metadata account. On secondary sales, your buy instruction reads the royalty basis points, calculates the creator's share, and routes it to the creator's wallet as part of the same atomic transaction.
Search and Filtering. Collection-level search, trait-based filtering, price range filters, and "recently listed / ending soon" sorts. All powered by your off-chain indexer. Use Elasticsearch or a PostgreSQL full-text search index depending on collection sizes.
User Profiles and Transaction History. Each wallet address gets an auto-generated profile page showing owned NFTs, listed NFTs, bid history, and transaction history. This is entirely off-chain data assembled from your indexer.
Notifications. Outbid alerts, sale confirmations, new listings from followed collections. Implement as a WebSocket push notification system with email fallback.
Support System. At minimum, an integrated Zendesk or similar helpdesk widget, plus a public FAQ covering wallet connection issues, failed transactions, and dispute resolution for buyer/seller conflicts.
Step 4: Architecture and Infrastructure Decisions
This is where most marketplace projects either get it right or accumulate technical debt that costs them months later.
On-chain vs. Off-chain Data Split. The correct model: store ownership, pricing, and transfer history on-chain (immutable, trustless); store metadata, media files, search indexes, and user-generated content off-chain. NFT media goes to IPFS or Arweave (permanent, content-addressed). Arweave is preferable for production — it's a one-time permanent storage fee, vs. IPFS where persistence depends on pinning services staying operational. Metadata JSON should reference the Arweave URI in the on-chain Metaplex metadata account. Wallets that display NFT metadata — including non-custodial DeFi wallets — fetch it by resolving this URI, so broken metadata links directly damage your users' experience in third-party apps.
RPC Node Strategy. Do not use Solana's public RPC endpoints in production. Public endpoints are rate-limited and have no SLA. Use a dedicated RPC provider (Helius, QuickNode, Triton) from day one, or run your own validator node for maximum control. Budget for this — dedicated Solana RPC at production scale costs $200–$2,000/month depending on request volume.
In a real estate tokenization NFT platform we delivered, the backend architecture operated across three distinct layers that each had different latency and consistency requirements. The blockchain interaction layer — wallet creation, on-chain balance checks, transaction broadcasting — ran as an isolated microservice with its own retry queue, because on-chain operations fail differently than database operations: a transaction can be accepted by the RPC node but dropped before confirmation, or confirm with a different fee than estimated.
We ran a node for each supported network in a dedicated infrastructure zone, separate from the application servers. This matters for your project timeline: if you start node provisioning on day one of development, they're ready when integration begins. If you don't, node sync becomes the critical path blocking go-live.
The metadata layer — NFT descriptions, media files, off-chain attributes — was stored in a separate service with IPFS as the persistence layer and PostgreSQL as the index. This keeps your on-chain data minimal (just the content hash) while giving users fast metadata retrieval through a standard REST API.
Indexer Architecture. Your marketplace's indexer subscribes to your program's account changes and transaction logs via Solana's WebSocket API (logsSubscribe and accountSubscribe). On each relevant event — listing created, bid placed, sale completed — the indexer parses the instruction data, updates the PostgreSQL tables, and invalidates relevant cache entries. Without a reliable indexer, your frontend would need to make multiple RPC calls per page load, which doesn't scale.
Transaction Retry Logic. Solana transactions can be dropped before confirmation due to leader scheduling and network variance. Your backend must implement retry logic for all user-initiated transactions: submit, poll for confirmation with exponential backoff, resubmit with updated recent blockhash if the original expires. The Solana Web3.js library provides primitives; wrapping them in a reliable retry service is your responsibility.
Step 5: UI/UX and Frontend Stack
The best-performing Solana NFT marketplace interfaces share common patterns: dark-mode-first design (the NFT audience expects it), card-based grid layouts optimized for visual browsing, and wallet connection as the primary CTA rather than traditional email registration.
Technical stack for the frontend:
- Web framework: Next.js (React) — SSR for SEO on collection and NFT pages, client-side rendering for the trading interface
- Solana integration:
@solana/web3.js,@solana/wallet-adapter-react,@metaplex-foundation/umi - State management: React Query for server state (NFT listings, prices), Zustand for client state (wallet, cart)
- Mobile: React Native for iOS/Android — shares wallet adapter logic with the web app
Mobile app architecture (iOS + Android):
- Programming languages: Swift (iOS), Kotlin (Android), or React Native for shared codebase
- Architecture patterns: MVVM for Android; MVC/MVVM for iOS
- IDE: Android Studio, Xcode
Step 6: Smart Contract Development with Anchor
Solana programs are written in Rust, deployed on-chain, and called via instructions from your frontend or backend. The Anchor framework is the standard for new Solana program development — it generates IDL (Interface Definition Language) files that your frontend uses to construct and decode instructions, handles account validation boilerplate, and provides a testing framework.
Your marketplace will need at minimum these programs:
- Listing program: Creates a PDA escrow account that holds the NFT and records price, seller, and expiration. Handles cancel and purchase instructions.
- Auction program: Extends the listing program with bid tracking, automatic refunds, and time extension logic.
- Offer program: Allows buyers to make collection-wide or item-specific offers without listing the NFT first.
- Royalty enforcement: Either native pNFT integration or custom transfer hook program.
In one of our NFT marketplace projects, the smart contract layer had to handle three distinct token types simultaneously: platform-issued NFTs with embedded prizes, user-created NFTs minted from physical product QR codes, and collection NFTs with gamification rewards. Each type required separate minting logic and access control, implemented as separate Solana programs rather than one monolithic contract.
The QR-scan minting flow — where scanning a physical label triggers an on-chain mint and transfers ownership to the scanner's wallet — required a Program Derived Address (PDA) to associate the physical code hash with a specific NFT mint authority. A key lesson from production: test your PDA derivation logic exhaustively. If two users scan the same code before the first transaction confirms, you get a race condition on account creation. We solved this with a commitment flag in the PDA data account — the second scan reads the flag and returns an "already claimed" error before attempting to initialize.
Step 7: Backend and Server Infrastructure
Your backend handles all computation that shouldn't (or can't) happen on-chain: user authentication, notification delivery, media processing, search indexing, and off-chain business logic.
Technical stack for the backend:
- Frameworks: NestJS (Node.js) or Spring Boot (Java) for the API layer
- Databases (SQL): PostgreSQL (primary), MySQL as alternative
- Databases (NoSQL): MongoDB for flexible NFT metadata, Redis for caching and real-time auction state
- Search: Elasticsearch for full-text and trait-based NFT search
- Message queue: Apache Kafka or Redpanda for blockchain event processing
- DevOps: GitLab CI/CD, Docker, Kubernetes (for scaling), Terraform for infrastructure as code
- Media storage: Arweave for permanent NFT assets, S3-compatible storage for thumbnails and previews
A microservices architecture is the right choice if you plan to scale beyond 10,000 DAUs or need independent scaling of specific components (the indexer and notification service have very different traffic profiles from the API gateway). For MVP, a well-structured monolith is faster to ship and easier to debug. The principles of blockchain application architecture — separating chain interaction, business logic, and data persistence into distinct layers — apply here regardless of whether you go microservices or monolith.
Step 8: Security Audit and Testing
Security for Solana NFT marketplaces is a different discipline from standard web application security. The attack surface is primarily at the smart contract level, and a vulnerability there means direct, irreversible loss of user funds and NFTs.
Security testing for NFT platforms is not standard QA — it requires adversarial thinking specific to the on-chain environment. In our deployments, we run three categories of smart contract tests before mainnet: unit tests for each program instruction (written in Rust with the Anchor test framework), integration tests against a local validator (solana-test-validator), and adversarial tests that attempt known attack vectors — unauthorized signer injection, invalid PDA seeds, arithmetic overflow in fee calculations, and re-initialization attacks on already-created accounts.
We don't consider a platform production-ready until deposit, minting, and withdrawal flows have been tested with actual mainnet assets — small amounts, but real. Devnet behavior differs from mainnet in ways that matter: RPC rate limits, confirmation times under real network load, and minimum rent-exempt balance calculations can all diverge. We've seen devnet-tested contracts fail on mainnet specifically because of RPC throttling under load. Add a staging environment on mainnet with a separate wallet and budget for it.
Smart contract audit checklist for Solana programs:
- Signer authorization on all mutating instructions
- PDA derivation consistency (same seeds produce same address)
- Arithmetic overflow/underflow in fee calculations (use
checked_add,checked_mul) - Re-initialization attacks on accounts (check
account.data_is_empty()before initialization) - Lamport drain attacks on PDA accounts
- Upgrade authority control — who can deploy a new version of your program
Commission a third-party Solana program audit before mainnet launch. Reputable auditors include OtterSec, Neodyme, and Trail of Bits. Budget $15,000–$50,000 for audit scope depending on program complexity. This is not optional — it's the minimum bar for user trust in a platform holding real assets. The principles of crypto platform security apply to NFT marketplaces with equal force: users will not return to a platform that loses their assets once.
Step 9: Launch Checklist and Post-Launch Operations
Launch is not the endpoint — it's the transition to a different operational mode. A Solana NFT marketplace in production requires ongoing attention to infrastructure that has no equivalent in standard web apps:
- RPC endpoint monitoring: Alert on latency spikes and error rates from your RPC provider. Have a failover endpoint configured.
- Upgrade authority management: Decide pre-launch whether your program is upgradeable (faster bug fixes, more trust required from users) or frozen (immutable, but a critical bug means a full redeployment at a new address).
- Program version strategy: Use a proxy/router pattern if you anticipate program upgrades — this lets you upgrade logic without changing the program address your frontend and indexer reference.
- Incident response playbook: Define what happens if your indexer falls behind, if RPC errors cause transaction failures, or if a smart contract vulnerability is discovered. Who gets paged? What's the communication to users? This is standard operating procedure for any Web3 marketplace operating with real user funds.
How to Evaluate a Solana Development Team: Technical Checklist
When sourcing a development team for your Solana NFT marketplace, the gap between a team that says they know Solana and one that has production Anchor program experience is significant — and the difference shows up after you've already paid for months of development. Here's what to verify:
- Can they show deployed mainnet program addresses you can inspect on Solana Explorer?
- Do they have experience with the Metaplex Token Metadata standard, including pNFTs and collection verification?
- Have they built custom Anchor programs (not just used SDKs)?
- Can they describe their approach to transaction retry logic and indexer architecture?
- Have they worked with Arweave or IPFS for NFT metadata storage?
- Do they have experience with Solana's rent model and how it affects account lifecycle?
A team with genuine Solana NFT development experience will answer these questions with specifics, not generalities. Vague answers about "blockchain expertise" without Solana-specific detail is a red flag.
The Cost of Building an NFT Marketplace on Solana
Cost depends on four variables: scope, team structure (in-house vs. agency vs. freelancers), geographic arbitrage, and whether you're building custom programs or extending existing protocols.
| Development Component | MVP Scope | Full Platform |
|---|---|---|
| Smart contracts (Anchor programs) | $8,000–$15,000 | $20,000–$50,000 |
| Smart contract security audit | $10,000–$15,000 | $20,000–$50,000 |
| Backend API + indexer | $10,000–$20,000 | $25,000–$60,000 |
| Frontend (web) | $8,000–$15,000 | $15,000–$35,000 |
| Mobile apps (iOS + Android) | Not included | $20,000–$50,000 |
| UI/UX design | $5,000–$10,000 | $10,000–$25,000 |
| QA and testing | $3,000–$7,000 | $8,000–$20,000 |
| Infrastructure setup | $2,000–$5,000 | $5,000–$15,000 |
| Total estimate | $40,000–$80,000 | $100,000–$300,000+ |
Timeline: MVP (listing, minting, buy/sell, wallet connect, basic UI) — 6–10 weeks. Full production platform with mobile apps, advanced auction mechanics, royalty enforcement, admin panel — 4–6 months. Smart contract audit adds 2–4 weeks to the timeline and should be scoped from the project start, not added at the end.
For comparison, launching on Solana's existing infrastructure (as a marketplace aggregator or white-label on an established protocol) rather than deploying your own programs can cut initial development cost by 40–60% — at the cost of differentiation and program control. If your competitive advantage is in the NFT vertical or community rather than in novel on-chain mechanics, this trade-off may be worth it. White-label NFT marketplace solutions offer the fastest path to an operational platform.
FAQ
What programming language is used for Solana NFT smart contracts?
Solana programs are written in Rust, typically using the Anchor framework as a higher-level abstraction. Anchor handles account deserialization, access control, and error management, and generates IDL files that your frontend uses to interact with the program. C and C++ are also officially supported but rarely used in practice for NFT marketplace development.
What is the Metaplex standard and do I need it?
Metaplex is the dominant NFT standard on Solana. It defines how NFT metadata is stored on-chain (Metaplex Token Metadata), how collections are structured and verified, and provides the Token Auth Rules program for programmable NFTs (pNFTs) with royalty enforcement. Almost every serious Solana NFT marketplace uses Metaplex — building your own token metadata standard from scratch would make your NFTs incompatible with every wallet and aggregator in the ecosystem.
What are compressed NFTs (cNFTs) and should my marketplace support them?
Compressed NFTs use Solana's ZK Compression and concurrent Merkle trees to store ownership data off-chain with on-chain proofs, reducing minting cost from ~$0.0004 per NFT to roughly $0.000005. If your marketplace use case involves high-volume, low-value NFTs — in-game items, loyalty rewards, event tickets — cNFT support is not optional, it's the feature that makes your economics viable. Tensor was one of the first major marketplaces to support cNFTs at scale.
How does wallet integration work on a Solana NFT marketplace?
Solana wallet integration is standardized through the Wallet Adapter library (@solana/wallet-adapter-react), which supports Phantom, Solflare, Backpack, Ledger, and all major Solana wallets through a single interface. Wallets serve dual purposes: they authenticate the user (no email/password needed) and sign all on-chain transactions. Your frontend never holds private keys — it requests the user's wallet to sign a pre-constructed transaction, then submits it to the RPC endpoint.
How are NFT royalties enforced on Solana?
Traditional Metaplex NFTs record royalty basis points in on-chain metadata, but enforcement depends on marketplace cooperation — a marketplace can simply skip the royalty payment. Programmable NFTs (pNFTs), introduced by Metaplex, enforce royalties at the protocol level using Token Auth Rules: a pNFT can only be transferred through programs that are explicitly authorized, and those programs are required to pay royalties as a condition of authorization. If creator royalties are your value proposition, build on pNFTs from the start.
What is the difference between IPFS and Arweave for NFT metadata storage?
Both are decentralized storage protocols used for NFT metadata and media. IPFS is content-addressed and free to upload, but persistence depends on pinning services — if nobody pins your files, they disappear. Arweave charges a one-time fee for permanent, immutable storage guaranteed by an endowment model. For production NFT marketplaces where asset permanence is a promise to your users, Arweave is the more reliable choice. Bundlr (now Irys) simplifies Arweave uploads with a developer-friendly API and SOL payment support.
How long does it take to build a Solana NFT marketplace?
A focused MVP covering wallet connect, minting, fixed-price listing, and buy/sell takes 6–10 weeks with a dedicated team (1 Solana program developer, 1 backend, 1 frontend, 1 QA). A full production platform with auction mechanics, mobile apps, royalty enforcement, admin panel, and smart contract audit takes 4–6 months. Smart contract audits add 2–4 weeks and should be scheduled from the project start — not treated as a last step.
Do I need to run my own Solana node?
For development and testing, public RPC endpoints are sufficient. For production, you need either a dedicated RPC provider (Helius, QuickNode, Triton) or your own validator node. Public endpoints are rate-limited, have no SLA, and will throttle your indexer under load. Dedicated Solana RPC at production scale costs $200–$2,000/month. Budget for this from day one — RPC reliability directly affects your marketplace's transaction success rate and user experience.
