Anchor Program Development
On-chain programs in Rust with Anchor, designed around Solana's account model with explicit ownership checks, PDA design, and compute budgets in mind from day one.
011Solana Blockchain Development
Solana Blockchain Development Services
Webisoft builds Solana programs and the products around them: Rust and Anchor on chain, fast indexed APIs and clean web apps off chain. Senior engineers in Montreal who understand why Solana's execution model changes how you design software.
Blkch002
What we build
Solana development across the full product
Solana rewards teams that design for its account model and parallel runtime instead of porting Ethereum habits. We build natively for it.
Token and NFT Systems
SPL tokens, Token-2022 extensions, and Metaplex-based NFT infrastructure, including mints, vesting, and royalty logic that behaves correctly under load.DeFi and Trading Infrastructure
Programs and services that integrate with Solana DEXs, liquidity, and oracle feeds, engineered for the latency and ordering realities of the chain.Indexing and APIs
Geyser-based pipelines and RPC strategies that turn raw account updates into queryable data, so your app never blocks on getProgramAccounts.Wallet-Ready Frontends
React apps with wallet adapter integration, transaction building with priority fees, and honest UX for confirmation states and dropped transactions.Program Audits and Rescue
Reviews of existing Solana codebases covering account validation, signer checks, and arithmetic, with a prioritized remediation plan you can act on.
How we work
A Solana engagement, step by step
(4)- 1
Design for the Runtime
We map your product onto Solana's account model, define PDAs and state layout, and budget compute per instruction before writing program code. - 2
Program Development
Anchor programs built with full test suites, local validator and devnet testing, and every account constraint written down and enforced in code. - 3
Off-Chain Build
Indexers, APIs, and the frontend are built against devnet in parallel, with weekly demos so you see the real product taking shape, not a report about it. - 4
Mainnet and Operations
We manage the mainnet deployment, set up monitoring for program behavior and RPC health, and stay engaged for iteration after launch.
Why Webisoft
Solana is not EVM, and we build like it
Many shops write Solana programs the way they wrote Solidity and it shows in exploits and compute failures. We engineer for the chain you are actually on.
Rust Depth
Our engineers work in Rust as a primary language, not as a translation layer from another ecosystem, which matters for both safety and performance.Security by Constraint
Account validation, signer checks, and ownership constraints are treated as the core of the program, because on Solana that is where funds are lost.Full Product Ownership
One senior team delivers the program, the indexing, and the app, so there is no gap between what the chain does and what users see.Senior Team, Direct Access
You work directly with the Montreal engineers building your system. Decisions get made in days, not routed through account managers.
FAQ
Common questions about Solana development
(4)- Solana fits products that need high throughput and low, predictable fees, such as consumer apps, trading systems, and high-frequency on-chain activity. EVM chains still have the deepest DeFi liquidity, the largest developer pool, and the most mature tooling. The decision usually comes down to whether the product depends on existing EVM liquidity and composability or on raw transaction speed and cost, and for some products the honest answer is that Solana is not the right fit.
- A focused Solana program with a web app typically runs a few months from architecture to mainnet. Protocol-scale systems with custom indexing, multiple integrations, and audits run longer, often six months or more. An architecture phase at the start of the project is the most reliable way to get a concrete timeline, because it surfaces the account design and integration work that drives the schedule.
- Any Solana program that will hold or move user funds on mainnet should get an independent third-party audit. Standard practice is for the development team to run internal security reviews, prepare the codebase with tests and documentation, and then remediate whatever the external auditors find. Solana audits focus heavily on account validation, signer checks, and compute limits, which are the most common sources of exploits on the network.
- Yes. The usual approach is a review of the programs and infrastructure that flags account-validation issues, compute problems, and architectural risks, followed by a written remediation plan. From there the codebase can be stabilized, extended with new features, or handed to a new team for ongoing development. Rescue and takeover work is a routine part of the Solana ecosystem given how many projects were built quickly during peak cycles.
Where we add value
Solana engineering beyond the tutorial level
Solana rewards teams that understand its runtime and punishes those that port Ethereum habits. We build programs and dApps around Solana's account model, fee markets, and parallel execution, which is where its speed advantage is actually won or lost.
Anchor and native Rust programs
We build with the Anchor framework for its account validation and IDL generation, and drop to native Rust where compute budget or binary size demands it. Program design starts with the account model: which state lives where, who pays rent, and how accounts are sized, because those decisions are expensive to change after deployment.Performance and compute optimization
Every Solana instruction runs inside a compute unit budget, and transactions compete in local fee markets on hot accounts. We profile compute usage, structure state to avoid write-lock contention so transactions parallelize, and use address lookup tables to fit complex operations in a single transaction. This is the difference between theoretical and actual throughput.SPL tokens and Token-2022
We implement token mints, vesting, and distribution using the SPL token program, and use Token-2022 extensions like transfer fees, transfer hooks, and confidential transfers where the product needs them. Extension choice matters because wallet and exchange support varies, and we validate compatibility with your target venues before committing.DeFi, NFT, and payments builds
We build the product categories Solana is strong at: DEX and liquidity integrations through Jupiter and major AMMs, NFT projects on Metaplex including compressed NFTs for large collections, and payment flows with Solana Pay. Compressed NFTs deserve a specific mention: they reduce minting costs by orders of magnitude for collections in the millions.Security for Solana's model
Solana has its own exploit classes: missing signer checks, missing account ownership validation, arbitrary CPI attacks, and type confusion between accounts. Our review process targets these specifically, alongside fuzzing and invariant testing, and we prepare programs for external audit by firms that know the Solana runtime rather than generalist reviewers.RPC and transaction infrastructure
Landing transactions reliably on Solana requires infrastructure decisions: dedicated RPC providers, priority fee estimation, transaction retry logic, and Jito bundles when execution ordering matters. We also build the indexing side with tools like Helius webhooks or custom Geyser plugins, so your app reads chain state in milliseconds instead of polling.
Our approach
How a Solana engagement runs
(4)- 1
Design around the account model
We begin with a specification phase covering account structures, instruction set, compute budgets, and the economic and threat models. On Solana, state layout drives both cost and parallelism, so we design it before writing program code and document the reasoning for your team and future auditors. - 2
Program development with tests as the spec
Programs are built in Rust with Anchor, with a test suite covering every instruction path, adversarial inputs, and the invariants that must hold across state transitions. We test against a local validator and devnet continuously, and the IDL is published early so client work can start against real interfaces. - 3
Client, indexing, and integration
In parallel we build the web client with wallet adapter support, the transaction construction layer with priority fees and retries handled properly, and the indexing pipeline that feeds your app and analytics. Milestones are demoed as complete flows on devnet, from wallet connect to confirmed state change. - 4
Audit, mainnet, and operations
We prepare the audit package, remediate findings, and execute the mainnet deployment with a rehearsed script, multisig authority, and a staged rollout where the product allows it. Post launch we monitor program activity, RPC health, and fee conditions, then hand over documentation, infrastructure, and keys under your control.
FAQ
Questions buyers ask about Solana development
(6)- Program complexity is the main driver: the number of instructions, the novelty of the mechanism, and how much state coordination the design requires. A token launch with vesting on proven patterns is weeks of work; a novel DeFi protocol with custom market logic is months plus a substantial audit. Rust and Solana specialists are scarcer than Solidity developers, which is reflected in rates across the industry, but Solana's low transaction costs usually repay that at the operating stage. We quote after a short design exercise rather than from the pitch deck.
- Choose Solana when your product needs high transaction frequency, sub-second confirmation, and fees small enough to ignore, such as order book trading, consumer apps, payments, or gaming. Choose Ethereum or its L2s when you need its DeFi liquidity, EVM tooling, or conservative institutional expectations. The honest answer is workload dependent, and since we build on both, we will tell you if your product economics point away from Solana rather than force the fit.
- Solana programs fail differently from EVM contracts, so we design against its specific exploit classes from the start: signer and ownership checks on every account, validated CPIs, and careful account discriminators. Before an external audit we deliver full test coverage, fuzzing results, and a written threat model, which shortens the audit and cuts its cost. We recommend audit firms with real Solana track records and book them early, since the good ones queue weeks out. Privileged operations go behind a multisig such as Squads before mainnet.
- Yes, Solana programs are upgradeable by default through an upgrade authority, which is both convenient and a centralization risk your users will ask about. We place the upgrade authority in a multisig, optionally with a timelock, and for protocols where trust is the product we can make the program immutable by burning the authority once it has stabilized. The right posture depends on how much value the program custodies and how mature the code is, and we help you sequence from upgradeable to locked as the product proves out.
- Reliable transaction landing is an engineering discipline on Solana, not luck. We implement dynamic priority fee estimation, durable retry logic that respects blockhash expiry, and write-lock aware state design so your transactions do not contend with unrelated traffic on hot accounts. For flows where ordering or inclusion matters, we use Jito bundles and dedicated RPC infrastructure rather than public endpoints. Products built this way kept working through congestion events that broke naive integrations.
- We start with a scoping call, then a short paid design phase that produces the account model, instruction specification, infrastructure plan, and a costed build estimate. That document is useful even if you build elsewhere, and it means the budget you approve is grounded in a real design rather than a guess. A typical first milestone, a working core flow on devnet, lands within the first several weeks, so you see the product moving before the majority of the budget is spent.
