Launched this week
SonOf
Empty your backlog. Pay only when it ships
79 followers
Empty your backlog. Pay only when it ships
79 followers
Connect your repo and PM tools. SonOf audits the codebase, writes and estimates the tickets, and ships the ones you approve. A senior engineer signs every plan and reviews every PR. Billed only when code hits production. Rejected work costs $0.
SonOf
Hey Product Hunt π Oleksii here, one of three makers.
For 8 years we've run Fulcrum, a dev studio β 100+ products shipped. Every client conversation started with the same two questions: how much will it cost, and when will it be done?
And for years, my honest answer was: it depends.
It depends on a pile of risks. A pile of nuances. Work everything out properly upfront β that's waterfall, and it takes forever. Go with an open check β the risk shifts to the client: they might pay more than they planned. Either way, one thing was constant: clients pay for hours.
Lately there's a third option. Founders try to build with AI themselves. They burn weeks and tokens β and rarely reach real production. Limitations show up. Slop shows up. The money is already spent.
Here's the uncomfortable accounting truth behind all three paths: unfinished work is money that never capitalizes. Half-built features, slipping roadmaps, abandoned prototypes β pure spend, zero asset. Only code in production converts money into value.
And a second problem I kept seeing with non-technical founders: they can't evaluate whether an engineer is good, can't predict budgets, can't see risks. The outsourcing model quietly transfers all of that responsibility onto the person least equipped to carry it.
That's why we built SonOf β for ourselves first. It started as an internal engine to push Fulcrum client work through faster. After ~10 engagements ran on it, we realized we'd built the product. (Yes, it's named after Son of Anton β Gilfoyle's AI in Silicon Valley. We're that kind of team.)
SonOf reads your entire product β repo, tickets, docs β as one context, and does the discovery work that used to take weeks. What you get is something the old model could never give:
β Full visibility over scope, before you spend anything. Every piece of work becomes a ticket with a fixed price on it β $500 per story point.
β The timeline in your hands. You approve tickets one by one β what to build, in what order, at what pace.
β Payment lands where value lands. You're billed only when code reaches production β the moment spend becomes an asset. A senior engineer signs every plan and reviews every PR before merge. Rejected work costs $0.
See what that does to the two problems above? You don't need to judge engineers, budgets, or risks anymore.
So after all these years, my answer finally changed β not because we work differently now, but because the client finally sees what we see.
How much? It's on the ticket, before you say yes.
When? You set the pace β approve, and the engine works around the clock.
Not "it depends."
The audit of your product is free: connect a repo, see your whole map. I'll be in the comments all day.
Sounds interesting! But how can a non-technical client verify that the estimates are adequate and the code quality is high?
SonOf
@svitlana_filipova1Β
Honest answer: they can't β and that's exactly the problem we built the model around.
A non-technical founder can't verify estimates or code quality at any agency, freelancer, or in-house hire either. The traditional model just hides it: you find out the estimate was wrong when the invoice grows, and that the code was bad a year later.
So instead of asking clients to verify, we removed the need to:
Estimates: every ticket has a fixed price before you say yes. If our estimate is wrong, that's our loss, not yours β the price doesn't move after approval.
Quality: you judge results, not code. Review the working feature on staging β if it's not right, we redo it free. Still not right β money back. Rejected work costs $0.
And the exit is honest: cancel anytime and keep the audit, the knowledge base, and every shipped PR.
We only get paid when code reaches production, so shipping bad code or inflating estimates costs us directly. Incentives do the verifying.
Plus the audit is free β you see how we read your codebase before spending a dollar. That's the quality sample.
pay-only-when-it-ships puts the risk on you, not me. that's the rare part. does the senior engineer sign the plan up front, or only review the final pr?
SonOf
Hey @andrewzakonov β both, actually:
Up front: the engineer reviews the plan and the estimates the system produced, tweaks if needed, and signs off before anything gets built.
Before staging: same engineer reviews and tests the PR.
You review on staging β happy with the result, it goes to prod.
And yes, the risk sits with us by design. It's what forces the plan-signing to be real rather than a rubber stamp β if we ship nothing, we earn nothing.
Charging on outcome instead of effort is rare, and customers notice, most tools bill you for trying and failing. The operational risk is disputes: what counts as shipped, who arbitrates, what happens on a half-done feature. Get that airtight and this is genuinely differentiated.
SonOf
@shivangit26 Thank you β and you're right, disputes are where outcome-based pricing usually dies. Here's how we've made it airtight:
What counts as shipped: code in production. Not "done," not "in review" β deployed. That's the billing trigger, so there's no gray zone to argue about.
Who arbitrates: the client, before the money moves. You review the feature on staging β if it's good enough, you approve and it ships. If not, we redo it free. Still not right β money back. Rejected work costs $0.
Half-done features: they don't get billed, period. A ticket either reaches production or it costs nothing.
And the part that keeps disputes from happening at all: before we take a ticket, we review the input β PRD detail, designs, whatever context exists (we parse Slack, Notion, Jira). If it's thin, we write out our assumptions and limitations, and the client signs off on those before we build. Most disputes are really scope disagreements in disguise; we surface them at ticket time, not at invoice time.
The bet underneath: models keep getting better at working with context, so this burden shrinks every quarter. But we didn't price on that hope β the guarantee works today.
Love the name! π
What do you see as the main use cases for the product? I'd love to understand where you think it provides the most value.
SonOf
@yuliia_pronΒ Good question. We see three situations where it earns its keep:
You inherited a codebase you can't read. Solo founder, v1 built by a freelancer, an agency, or vibe-coded with Lovable/Bolt β the original developer is gone, the product runs, and nobody knows what's inside. The free audit alone solves half the problem: you finally get a map of what you own.
Your backlog grows faster than your team ships. Founder-led startup, a few in-house devs, and a backlog that's mostly going to die there. SonOf takes the tickets your team will never get to β you approve, it ships, your devs stay on the core.
You can't hire fast enough. Eng teams where the roadmap slips quarter after quarter because every hire takes months. Extra shipping capacity without headcount, and without the agency markup.
The common thread: the value isn't "AI writes code" β it's that unfinished work finally becomes shipped work, and you pay only when it lands in production.
Honestly, the fastest way to see where it helps you is the audit β it's free and it tells you what's broken and what's ready to build before you spend anything.
DIY UX Test
Congrats on launch! What are the numbers of how it impacted the projects you'd already delivered?
SonOf
@kateryna_khalimonchukΒ thanks!
We ran ~10 client engagements through the engine before opening it up, and two of them converted to ongoing paying customers. The cleanest number we have is cost per identical deliverable: work that quotes at $4β16K with freelancers or $10β30K at an agency lands at $1β5K through SonOf. Same scope, same production bar β a senior engineer still signs every PR.
If you want a number about your project instead β the audit is free, and it tells you exactly what's sitting in your backlog and what it would cost to ship.
Genuinely impressed that the billing only triggers on code that ships to production. The senior engineer review on every PR gave me confidence to let it touch real tickets instead of just test repos.
SonOf
@masal1468301Β Thank you!