The work starts before any contract
Tell us what you are building. A Protofire engineer reads it before the discovery call, and one business day after the call you hold a written proposal: findings, a phased plan, a range, and a first step. This page shows the sequence, the principles it runs on, and what you plug into beyond the engineering team.

Reviewed by Luis Medeiros, Field CTO at ProtofireLast reviewed: September 2026
secured across 120+ networks as an official Safe Guardian
developers run Solhint, the linter we maintain
projects delivered since 2016
From first message to proposal in four steps
Tell us what you are building
Your application is a description of the project in your own words. Add whatever exists: a deployed demo, a repository, a product site. Working code gives the engineer more to verify, but a clear description is enough to start. We reply within one business day.
An engineer reads it
Before anyone gets on a call, an engineer has been through everything you sent and formed a first technical read. Senior time goes in before the first conversation, so we take the projects where that reading finds something worth building on.
The discovery call
You talk to the engineer who read your work, together with a business lead. We walk through what exists, what it should become, and the constraints that matter: chain, custody, compliance, runway.
The written proposal, one business day later
The facts we verified in your code and what each implies, a phased plan to production, an estimated range and timeline, and a recommended first step. On paper, specific to your code, with the range stated per phase.
The proposal is written to be forwarded: to a cofounder, a CTO, a board. It stays useful even if you never work with us.
The proposal, shown before you ask
Below is the written proposal as clients receive it: a worked example built on a typical AI-built-prototype engagement, with the structure real and the client specifics invented for illustration. Yours is written about your code.
The product logic is proven: the flows work end to end and the demo holds together under a first read.
Implication: The build is worth hardening rather than restarting; every phase below assumes your codebase, not a rewrite.
The withdraw and parameter functions in the vault contract are callable by any address; access control exists only where the prompt mentioned it.
Implication: Access control is reworked before anything else in Phase 1; until then the contract cannot hold real funds.
Prices are read as spot values from a single pool, movable within one transaction; value-bearing math inherits that.
Implication: Pricing moves to an oracle-backed feed, and the affected math is re-tested against manipulated-pool scenarios.
The test suite restates the implementation, so it passes by construction; adversarial cases are absent.
Implication: An independent suite against intended behavior becomes the gate for Phase 1, in place of the current one.
An RPC key ships in the client bundle, and the backend simulates two of the flows the demo presents as onchain.
Implication: The key is rotated at kickoff, and the proposal names, flow by flow, what belongs onchain and what stays a service.
The deploy script pins an older compiler than the contracts declare, so local builds and the deployed bytecode disagree.
Implication: One toolchain is pinned and verified, so the bytecode an auditor reads is the bytecode that ships.
Show all six findings
The test suite restates the implementation, so it passes by construction; adversarial cases are absent.
Implication: An independent suite against intended behavior becomes the gate for Phase 1, in place of the current one.
An RPC key ships in the client bundle, and the backend simulates two of the flows the demo presents as onchain.
Implication: The key is rotated at kickoff, and the proposal names, flow by flow, what belongs onchain and what stays a service.
The deploy script pins an older compiler than the contracts declare, so local builds and the deployed bytecode disagree.
Implication: One toolchain is pinned and verified, so the bytecode an auditor reads is the bytecode that ships.
Phase 0 is priced as a small, fixed engagement. Phases 1 and 2 each carry their own range and timeline, refined after the review. The range is written per phase so you can stop at any boundary. In a real proposal this section carries the figures; they are the one specific we do not invent for a public example.
The scoped production-readiness review. It converts the findings above into a prioritized fix list with the cost of each path.
- The price of a phase is fixed against written acceptance criteria; overruns inside them are ours to absorb.
- Invoicing follows delivered milestones, not hours.
- Delays on your side move dates day for day; the price does not change.
- Change orders are scoped and priced before the work starts.
- Code, contracts, keys, and infrastructure are yours by contract.
A worked example with invented specifics; the structure is what you receive. Every real proposal is written about the code and constraints on the table.
What we tell you straight
If you do not need a blockchain, the proposal says so
Some products arrive with a chain in the plan and a database in their future. When that is the reading, we write it down in the proposal and recommend the smaller build.
We are not an audit firm
For code we build, we bring in external auditors rather than marking our own homework; for code we did not write, audit and pre-audit hardening are services we offer. The trail is public: Certora formally verified our ve8020 launchpad, and Pessimistic audited the DEX core we engineered for Swarm Markets.
Our depth is EVM
Solidity and the EVM stack are where our track record lives. If your build targets a different stack, we say so on the call.
If another kind of partner fits better, we name it
Sometimes the right answer is an in-house hire, a studio deal, or a scoped audit. The proposal says which.
The principles the work runs on
Three rules, visible in every proposal we send and every system we hand over.
Novelty only where it pays
Escrow math, voting curves, and vault standards start from contract lineages that have survived audits and mainnet use. New design work goes where your product differs.
Operate what we build
Our team runs nodes, explorers, indexers, and vaults in production around the clock. It shows in the engineering: monitoring, runbooks, and incident response are designed in from the start, and launches ship with them.
Honesty before contract
The proposal records what the reading found, including the findings that argue against hiring us: the smaller build, the missing piece, the case for a different kind of partner. We want onchain rails built well, wherever they get built, and saying the efficient path out loud is part of the job.
One partner for the whole build
A build needs more than code, and teams usually assemble five vendors to cover it. One engagement with Protofire covers the whole of it, in-house or through the network we have built since 2016, whether the requirement started as a whitepaper or as a regulator's deadline.
Engineering and security
The build itself: smart contracts, backend, frontend, and the external audit coordinated on the prepared codebase, with the scope package and remediation ours to run.
Token, tokenization, and incentive design
Tokenomics and staking economies for protocols; tokenization, stablecoin, and custody architecture for institutions, mapped to frameworks like MiCA. Designed by engineers who have shipped these systems to mainnet.
Infrastructure and operations
Nodes, RPC, explorers, and indexers deployed and run around the clock by our own infrastructure team, with monitoring, runbooks, and incident response.
Data and reporting
Subgraphs and indexing pipelines, dashboards, and the transparency reporting a token, fund, or regulated issuer needs its community, partners, and auditors to see.
Liquidity and market access
Introductions across the partner network a launch draws on: liquidity providers, market makers, custodians, and the venues a product needs after mainnet.
Ecosystem and go-to-market
Grant programs, foundations, and co-marketing inside the ecosystems we contribute to, from Safe to Chainlink to The Graph.
Where a piece sits outside us, the proposal says so and names the partner: external auditors sign off on code we write, and legal counsel stays yours.
What you plug into
One engagement connects you to the infrastructure Protofire already operates, the auditors and foundations we already work with, and 250+ shipped projects of prior art across 60+ networks and 95+ protocols.
Ecosystem roles
Protofire is an official Safe Guardian, a Chainlink core contributor, and operates The Graph indexers and Blockscout explorers in production around the clock.
Auditors on the record
For code we build, external auditors sign off: Certora formally verified our ve8020 launchpad, Pessimistic audited the Swarm Markets DEX core. Proposals include the audit scope package and a remediation window.
Open assets
Solhint, the Solidity linter used by 1M+ developers, is ours to maintain. The ve8020 launchpad is public. The reasoning behind every one of our blueprints is public, and the full spec goes to any work email.
The story since 2016, the long-term partner list, and the team behind all of this live on the about page.
Clients, on the record
What stood out most was their ability to handle both the smart contract and frontend sides of the project.
Protofire's team is engineers first, which shows in the way they communicate and problem-solve.
The Protofire team genuinely cares about its customers and puts all of its energy and talent into building outstanding products.


