The technical half of your company. Consultancy, POCs, delivery, AI automation and Web3 engineering — scoped in writing, delivered in days, owned end to end by the people who build it.
Free. You leave with a written scope and a price, whether or not you hire us.
What you don't have is anyone technical you can trust to tell you the truth about it.
01
Three quotes, 4× apart
None of them explains why. You have no way to tell which number is the honest one.
02
The last agency vanished
They shipped a demo, invoiced, and went quiet. Nobody can explain the codebase now.
03
Every call routes to you
You're making six-figure architecture decisions on instinct, because there's nobody else to make them.
04
A CTO takes 9 months
And $180k before equity. Your runway doesn't care how long hiring takes.
Take one. Take the stack. Either way there is a single person who answers for the architecture, the code, and the date.
We answer the technical questions you can't safely answer alone.
We review what you have or plan to build, then write down the decision: the stack, the tradeoffs, the failure modes, and what it costs you in six months.
We build the smallest working version of your idea, and it actually runs.
One core use case, built end to end and deployed where real users can touch it. A repository you own with a running deployment attached — not a prototype that works on our laptop.
We run the build so you don't have to babysit engineers.
A fuzzy goal becomes a scoped plan with dates. We own the standups and the tracker, and tell you early when something is slipping — over your team or ours.
Launch, infrastructure, and adoption — the work after the code is written.
Deployed on infrastructure you own, with domains, environments, monitoring and analytics wired up. Docs and quickstarts are product, and we treat them that way.
We put AI inside a workflow you already run, and measure whether it works.
We map the manual process, build the agent or pipeline that performs it, and instrument accuracy, latency and cost per run. If the numbers don't justify it, we say so before you commit.
Contracts and proof systems, built to be reviewed by someone hostile.
Contracts tested against adversarial conditions. ZK circuits where constraint count and proof cost are budgeted up front, not discovered late. Prepared for audit, not hoping to survive one.
How the work is shaped
Every engagement starts as a document: the problem, the boundary, what ships, what does not, and the date. You read it before anything is signed. Then it gets built in days, in your repo, against that document. Scope changes are a new document, not a surprise on the invoice.
What we tell you early
Some builds are bigger than the shape we work in. When yours is one of them, you get that in writing on the first call, with the honest range and the reason, even though it costs us the engagement. A build broken into pieces that hide its true size is a worse outcome than a clear no.
Pick the shape that fits the problem. Each one comes with a written boundary, a delivery date, and a number you see before you commit.
A written technical read on your product, from someone who would have to build it.
3 business days
Read the scope
Who it's for
Founders with a spec, a half-built codebase, or an agency quote they don't trust.
What's included
You end up holding
A 4–8 page technical brief, in your drive, yours to hand to any developer or investor.
Not included
Code. Designs. Vendor introductions. More than one codebase or spec.
Guarantee
If the brief tells you nothing you didn't already know, reply within 7 days and we refund it in full. You keep the document.
Most briefs end in one of three recommendations — a retainer, a single sprint, or a phased sequence. The brief names which, and the price.
A technical co-founder's judgment, on a meter you can see.
Monthly, rolling · 30 days notice
Read the scope
Who it's for
Non-technical founders with a dev team or contractor, and nobody senior to check the work.
What's included
You end up holding
A monthly written record of every technical decision and its reasoning — the thing that normally lives only in someone's head.
Not included
Implementation work. Being on call. Managing your developers day-to-day.
Guarantee
Cancel any time before day 30 of your first month and we refund that month.
When a retainer conversation turns into "someone needs to build this," it becomes a sprint — quoted from context we already have, no re-discovery fee.
One manual process your team repeats, running without them.
10 business days
Read the scope
Who it's for
Teams doing the same 20–60 minutes of copy-paste, triage, or data-shuffling every day.
What's included
You end up holding
A running automation, its source in your repo, and a runbook that lets someone else maintain it.
Not included
A second workflow. A UI or dashboard. Model fine-tuning. Systems with no API.
Guarantee
If the workflow doesn't run end-to-end on your data by day 10, you don't pay the second half.
Workflow two moves faster than workflow one — the integration, alerting and deploy plumbing is already yours.
One smart contract, written or torn down, by people who have shipped both.
12 business days
Read the scope
Who it's for
Teams shipping a single on-chain mechanism, or holding a contract they need read hard before mainnet.
What's included
You end up holding
The contract and its tests in your repo, or a severity-graded findings report you can send to your auditor.
Not included
A formal audit or certificate — this is pre-audit work and we say so in writing. Mainnet deployment or key custody. Contracts over 500 lines.
Guarantee
On the teardown track, if we return zero findings above informational severity, you pay half and keep the report.
Build-track output goes to a formal audit — we name firms and prep the package. Teardown output usually becomes a fix sprint.
One demo-able feature. Real code. Three weeks.
3 weeks from scope-lock
Read the scope
Who it's for
Founders who need to show one thing working — to a customer, an investor, or their board.
What's included
You end up holding
A live URL, the repository, and a demo recording.
Not included
Production hardening, scale, or SLAs. Payments or compliance. A second user path. Mobile apps. App-store submission.
Guarantee
Scope is locked in writing before we start. If the locked scope isn't demo-able at the end of week three, we keep working at no charge until it is.
POC to production is typically 3–6 sprints, not one. The closing note lays out that sequence with prices and gates.
Every engagement is fixed-price and agreed in writing before it starts. You get the number on the call, along with the scope it covers.
Ready when you are
Bring the problem, not the spec.
Most engagements start as one thing and get scoped into another on the call. Describe what you're trying to ship and we'll tell you which shape fits — or that none of them do.
Most calls end in one of two ways: a scope, or an honest referral elsewhere.
The edge is fixed
Every offer has a written edge — one workflow, one contract, one user path — signed off by both of us before work starts. That is what makes the price real.
When something doesn't fit
It happens on most projects, usually around day four. We stop and name it, then either trade it against something inside the locked scope, or quote it as the next sprint. You choose which.
Change requests
Priced before they are built, never after. Under two hours of work, we usually just do it.
What we will tell you
If your project is bigger than the shape we work in, you hear that in the first conversation, with the honest range and the reason. We'd rather lose the engagement than sell a sprint into the wrong problem.
There is no account manager, no discovery phase that bills for itself, and no handoff between the people who scope the work and the people who write the code. The engineer on your first call is on your first commit. Requirements do not degrade in translation, so the time between "we agree" and "it runs" is measured in days.
Most firms staff the work with whoever happens to be free. We staff it with the people you spoke to. They have shipped consultancy, POCs, delivery management, AI automation, and Web3 and ZK systems, and they carry the context rather than relaying it. You get judgment on the first call instead of questions taken back to someone senior.
Fixed scope requires knowing the shape of the work before quoting it, which requires refusing work whose shape is unclear. So the brief comes first, always, and it is a deliverable in its own right. By the time a number is attached, the boundary is written down, the unknowns are named, and both sides are agreeing to the same thing.
What you're building, what's stuck, what you've already spent. No deck from us.
Architecture, sequence, and the parts that will be harder than they look. You hear the reasoning, not just the conclusion.
What ships, what does not, when it lands, and the number attached to it. One document, before anything is signed.
The scope is yours. Build it in-house, hand it to another firm, or come back to us. No follow-up sequence, no invoice for the conversation.
This is the actual agenda. If nobody has asked you these, that is the problem we're describing.
What is the specific decision or deadline forcing this conversation now?
Tells us whether you need a build, an answer, or a second opinion. Three different prices.
What already exists — code, a design file, a spreadsheet someone runs manually?
There is almost always something. It tells us what we can build on instead of starting from zero.
Who keeps this running, and what happens the week they're unavailable?
Reveals the single points of failure that never appear in a requirements document.
Where does your data live, and who has the credentials?
Determines integration work, security scope, and whether you actually own your infrastructure.
What does the system need to survive — how many users, how much data, how often?
Real numbers change the architecture. Guessing high costs money; guessing low costs a rebuild.
What have you already tried that failed, and what was the failure?
The failure mode is the most useful information in the call. It tells us what not to repeat.
If this works, what is the one thing that becomes true afterward?
This becomes the acceptance criterion. If we can't state it in one sentence, the scope isn't ready.
Who has to approve this, and what would make them say no?
Surfaces the security review or the board question before it kills the work at week three.
Architecture review
Written technical brief: stack, tradeoffs, risks, cost model
POC / MVP build
Git repository in your organization, plus a deployed URL
AI automation build
Eval report: accuracy, latency and cost-per-run against a labeled test set
Smart contract work
Contract repo with Foundry test suite, coverage report, pre-audit findings
Launch / infra setup
Runbook: deploy steps, env vars, rollback procedure, on-call notes
Delivery management
Scope document, weekly written status briefs, and a decision log
Any build engagement
ADR log — every architectural decision, why it was made, what was rejected
Handover
Loom walkthrough of the codebase and deployment, for whoever inherits it
Scope locked in writing
The document lists what is out of scope as explicitly as what is in, so a mid-build request becomes a priced change rather than a silent delay.
Working software every week
Progress is a running deployment, not a percentage, because a demo cannot hide integration problems that a status update can.
Deployed where you own it
Your cloud account, your repository, your domain — so the engagement can end at any point without you losing access to what you paid for.
Tests are the acceptance criteria
"Done" means a defined test suite passes or an eval hits an agreed threshold, which makes the finish line something you can verify without trusting us.
Decisions written as they're made
The ADR log records what we chose, what we rejected, and why, so the next engineer can change our decisions instead of reverse-engineering them.
We don't have a slide of client logos. We have repositories. Read the code before you pay for any of it.
There is no account manager between you and the engineers. The people on your intro call are the ones who commit the code.
Rump Gurukul is our zero-knowledge proofs course. Anyone can claim ZK depth on a landing page. Fewer can teach it for weeks.
Your GitHub organisation, your cloud account, your keys, your domain. Our leverage is that you want us back, not that leaving is expensive.
Stated plainly, because finding out on week three is worse for both of us.
Compliance-certified healthcare or finance
HIPAA and SOC 2 need audit trails and organizational controls we can't honestly provide. Hire a firm with the certification on paper.
24/7 on-call SRE rotations
We work global hours and will build you monitoring and a runbook, but we are not a pager rotation. Staff it internally or use a managed provider.
Mobile app store operations
Release management and review appeals are an ongoing function, not a project. We'll build the backend; someone else should own the store.
Staff augmentation
We take ownership of scoped work, not seats on your org chart. If you need engineers embedded in your team for a year, you need a recruiting partner — and we'll say so on the first call.
Quarter-long enterprise programs
Everything here is scoped in days or weeks, against a boundary written down in advance. If the work genuinely takes three months, either our estimate was wrong or the engagement isn't ours — and you'll hear that in writing, not discover it three invoices in.
Still deciding
Bring the half-finished repo.
We'll tell you what it would take to finish it, what it would cost, and whether we're the right people to do it. You keep the scope either way.
No deck, no sales rep. An engineer takes the call.
Not silently. The scope document names what ships and what does not, and anything outside that boundary is a new document with its own number and its own date, agreed before work on it begins. You will never find added work on an invoice you did not approve first. Most engagements finish inside their original boundary because the boundary is written before money moves, not after the first surprise. If we misjudged the shape, that is our estimate to own, and we say so.
Don't take it on faith — take it on what you hold. The work is public, so read the repositories before you commit to anything. You get a written scope, with the boundary and the date, before any money moves. From day one the repository, the cloud account and the keys are yours, so leaving is easy and nothing is held hostage. And the guarantees cost us real money if we are wrong, which is the only kind of promise worth reading.
You do, from the first commit. Everything is built in your GitHub organisation, on your cloud account, with your keys. No wrappers, no licensed black box, no hosting you rent from us. If you fire us on day three, you keep every commit and any competent engineer can pick it up on day four.
Judge the code, not the timezone. Our repositories and technical writing are public — read them before you book. Then judge the terms: fixed price, written scope, weekly working demos, and a first month you can cancel. We work global hours with a live call at a time that suits you, and every deliverable lands in your repo where you can inspect it.
Then you probably don't want our build team — you want the Technical Brief or the Fractional CTO retainer. We add the layer above your devs: architecture decisions, code review, sprint discipline, and one person accountable for the ship date. Most stalled teams don't lack engineers; they lack someone arbitrating scope.
The structure is designed so that isn't fatal. Work lands continuously in your repository, deployments run in your cloud account, and every architectural decision is written down as it's made. Engagements are days or weeks, not quarters, so the maximum exposure is small by construction. And on retainer, thirty days' notice ends it with no penalty either way.
Realistic for one locked user path — one user, one journey, real data, deployed. It is not realistic for an unbounded product whose scope moves weekly. That's why week zero locks the build, and anything outside the lock becomes the next sprint instead of a slipped date. If your scope can't ship in three weeks, we'll tell you in the Brief — not after your money is in.
That's a completely normal outcome and it's priced to be one. The brief is written to be useful to whoever builds it, including a team that isn't us. Take it to another firm, hand it to your own developer, or use it to decide not to build at all. There's no follow-up sequence.
The next step is thirty minutes, and it costs nothing. Bring the idea, the stalled repo, or the quote that scared you. We'll tell you what it takes to build, what it costs, and whether we're the right people to do it.
If we're not, we'll say so on the call.
If we're the wrong fit, we'll say so on the call and not send an invoice for the opinion.
What happens on the call
You talk for ten minutes
What you're building, what's stuck, what you've already spent. No deck from us.
We scope it out loud
Architecture, sequence, and the parts that will be harder than they look. You hear the reasoning, not just the conclusion.
You get a written scope
What ships, what does not, when it lands, and the number attached to it. One document, before anything is signed.
You leave with the plan either way
The scope is yours. Build it in-house, hand it to another firm, or come back to us. No follow-up sequence, no invoice for the conversation.
