Skip to content

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.

Luis Medeiros

Reviewed by Luis Medeiros, Field CTO at ProtofireLast reviewed: September 2026

$2B+

secured across 120+ networks as an official Safe Guardian

1M+

developers run Solhint, the linter we maintain

250+

projects delivered since 2016

Trusted across 60+ networks and 95+ protocols

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.

A decision you can act on

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.

Written proposal
Prepared one business day after the discovery call
Worked example
Prepared for: your companyDate: the business day after your callPrepared by: the engineer who read your materials, with the business lead from your call
01 · What we verified, and what it implies

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.

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.

02 · What production requires, phase by phase
Phase 0Production-readiness review: full technical read of contracts, code, and infrastructure; prioritized fix list you keep.
Phase 1Harden and test: access control reworked, oracle-backed pricing, an independent test suite against intended behavior.
Phase 2Launch: deployment pipeline, monitoring and alerting, external audit coordinated on the prepared codebase, with the scope package prepared and a remediation window held.
Phase 3Operate (optional): monitoring, incident response, and routine operations run as a service.
03 · Estimated range and timeline

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.

04 · Recommended first step

The scoped production-readiness review. It converts the findings above into a prioritized fix list with the cost of each path.

05 · Commercial terms, the same in every proposal
  • 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.

01

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.

02

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.

03

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.
Head of Ecosystem, Quickswap5.0
Protofire's team is engineers first, which shows in the way they communicate and problem-solve.
Head of Ecosystem, Autonomys5.0
The Protofire team genuinely cares about its customers and puts all of its energy and talent into building outstanding products.
CEO & Co-Founder, Dowsers4.5
4.8 on ClutchVerified client interviews; quality rated 5.0 of 5.Read the reviews →

FAQ

How fast does Protofire send the proposal?
One business day after the discovery call, in writing. The clock starts at the call. What makes that speed possible is the reading that happens before it: your application describes what you are building, with any links you have, and an engineer has been through all of it before the conversation starts. Findings are only as specific as the material the engineer had to read, so send whatever exists; the pre-call read is a few senior hours over sampled paths, and the full review arrives as the first phase of the engagement.
What exactly is in the proposal?
Every proposal answers the same four questions: what we verified in your code and what it implies, what production requires phase by phase, what it costs and how long, and the first step we recommend. The same commercial terms travel with all of them: a range stated per phase that becomes a fixed price when the phase is commissioned, invoicing per delivered milestone, and IP that is yours by contract. The worked example on this page shows the structure as clients receive it; expect specific findings, and phases small enough to decide on one at a time.
What if there is no code yet?
A normal starting point. Describe the product, the users, and the constraints, and the proposal covers what belongs onchain, what does not, and what to build first. If you already hold an AI-built demo, the fast lane is our AI prototype to production practice. Working code makes the findings more specific, so send whatever exists, but an idea described well is enough for the call.
What do you need from us before the call?
A description of what you are building, in your own words. A link makes the reading richer: a deployed demo, a repository, a product site; private code travels fine as a temporary read-only invite. An NDA is available from the first message and can cover anything you share: the description, the demo, the code. Specifications, pitch decks, and settled architecture can all wait, because the call exists to pull those out of your head. Expect five questions on it: what the product does today and which parts are real versus simulated, what it should become, chain and stack preferences, custody, compliance, and jurisdiction constraints, and the timeline and runway the phases must fit.
What is Protofire's process, from first message to proposal?
Protofire's process runs start to finish: you apply with a description of what you are building and any links you have, and an engineer reads it all before anyone schedules anything. We reply within one business day, by email or Telegram, to set up the discovery call, thirty to forty-five minutes with the engineer who did the reading and a business lead. The call covers what exists today, what it should become, and the constraints that shape the build: chain, custody, compliance, timeline, runway. One business day after that call you receive the written proposal. It opens with the facts we verified and their implications, then a phased plan to production, a per-phase range and timeline, and a recommended first step; it is specific to your project, readable without us in the room, and priced per phase so you can stop at any boundary. The IP terms travel in the same document: everything produced under the engagement transfers to you.
Why work with Protofire instead of hiring an in-house team?
Most builds arrive at problems Protofire has solved in some form: 250+ projects across 60+ networks since 2016, with the contract lineages, deployment pipelines, and monitoring stacks from that work carrying over, and the relationships around them, from external auditors such as Certora and Pessimistic to the ecosystems we contribute to as a Safe Guardian, Chainlink core contributor, and Graph indexer operator. A senior in-house team also takes months to hire, while the first written proposal is in your inbox one business day after the discovery call. And when in-house fits your situation better, the proposal says so; our partner-choice guide compares the options in public.
What do we get beyond the engineering work?
The rest of the company. Our venture studio builds and funds its own products, so judgment about tokenomics, treasury, and go-to-market comes from people who run their own. Our infrastructure practice operates nodes, explorers, indexers, and vaults around the clock, so launches go out already instrumented, with someone on call. And a decade inside the ecosystems means the introductions a launch needs: auditors, foundations, grant programs, and integration partners.
Do you only work with crypto-native teams?
No. A growing share of the work is for regulated financial companies: banks, fintechs, and asset managers that arrive with a business requirement, a tokenized product, a stablecoin, a custody flow, and need it mapped to the rules that apply and built to production. The engagement runs the same way: describe the requirement, an engineer reads it, and the proposal lays out the phases. Our published blueprints for regulated builds show that side of the practice.
How does Protofire price projects?
Per phase, against written acceptance criteria. The proposal states a range and timeline for each phase; when you commission a phase, its price is fixed, and overruns inside the agreed scope are ours to absorb. Weekly demos run from the first weeks of the build, and invoicing follows delivered milestones. Delays on the client side move dates day for day without changing the price, and change orders are scoped and priced before the work starts. External audit fees are a pass-through: you pay the auditor directly, and the estimate appears in the proposal. Delivery closes with a hypercare window and a defect warranty, with their terms written into the same document.
Who owns the code and IP?
You do, by contract. Code, smart contracts, keys, infrastructure, and documentation transfer with the engagement; handover is a line item in the final phase, with repositories transferred, keys rotated to accounts you control, and documentation delivered before the last invoice. The findings and fix lists you receive stay yours if we part ways.
What happens after the proposal?
You decide, on a document that stands on its own. For most teams the recommended opening move is the scoped production-readiness review: a full technical read of contracts, code, and infrastructure that ends in a prioritized fix list. The list does not expire if we part ways there. And when the reading shows a different kind of partner fits your situation better, the proposal names the type.

Apply to build with us

Tell us what you are building; a link helps but is not required. We talk it through on a call, and a written proposal follows within one business day of the call.

Hi, my name's

Alejandro Losa

Protofire 2026. All rights reserved

Message us on Telegram