Every one of these started small.
Not one of these began as a big contract. They started as a single engineer on a first project — and grew, over years, into the work you see here. The model rewards clients who start small and stay long.
Most engagements run $40–$50 per hour — about $6,400–$8,000 per developer per month, with every dollar on the record. But the rate is the easy part. The harder, more useful question is how a working relationship begins, and how it grows.
Every dollar of the engineering fee is allocated against a fixed internal structure. Not a suggestion. A rule. It is what makes long-term partnerships economically possible — for both sides. Where a team also runs your production, that responsibility is charged and accounted for separately — the worked example below shows exactly how.
Goes directly to the person writing your code. Salary, benefits, the things that keep senior engineers from leaving after eighteen months. In most agencies this is the line most commonly squeezed. We do not squeeze it.
Goes to the engineer responsible for you — not a salesperson, not a project manager. They receive it only after you have paid, so they are paid when you are served, not when you are sold to. If they are not right, you can ask for someone else. This line is what makes a ten-, fifteen-, eighteen-year engagement continuous rather than a series of reboots.
Recruitment, onboarding, compliance, HR, tooling, quality, operations. Capped at twenty percent, transparently. Every point above twenty would come out of the engineer's seventy. That's why we hold the line at twenty.
The split isn't a discount. It's what produces an engineer who treats your business as his own — and stays for years.
Fixed price fits a first project with a clear boundary. Once the requirement is evolving, time-based billing fits better — here's why we use each where we do.
A fixed price can give you a single certain number. But it also means we can only deliver exactly what was signed — even when, halfway through, we find a better way to build it. Once there's trust, you're paying for our time and our judgment — and that's when we say what we really think, and the software gets better for it. The furthest point on the line is the one most firms never reach: you hand us the production environment, and we run it.
The most expensive mistake in software services is the one the client cannot see: turnover. Keeping the same team on a mission-critical system for eighteen years — and counting — is not a cost-saving strategy. It is the entire strategy.
Most of our long-running partnerships began with a small, bounded first project. Not a pilot, not a sales demo — a real piece of work that lets both sides find out how it feels to build together. Three steps, each with a clear price and a clear exit:
A senior engineer reads your codebase and sends written findings.
We scope a meaningful slice of the real work, fix the price, and deliver it.
The same engineer keeps going, billed by time, on a dedicated or time-and-materials basis.
A day or two of a senior engineer's time: they read your codebase and send a written report within a week of getting access — what's solid, what's risky, and what it would take to move it forward. No cost, and the findings are yours either way.
It's a read of the code, not a full discovery — that deeper work is what Start Small is for, and it's paid, because that's where the real thinking happens.
Get your free code health check →You often don't have time to define the work in detail — so we'll do it. We take a meaningful slice of what you need, scope it, fix the price, and deliver it.
And here's the honest part: under a fixed price, we deliver exactly what we agreed to. Along the way you'll see the real complexity inside the work — and the places where the requirement could actually be better than first imagined. That's the moment most clients understand why we don't run long engagements on fixed price. When you pay for our time instead, we say what we really think, and the software gets better for it.
So Start Small isn't just a small project. It's how trust begins — and how you find out whether we're right for you before committing to anything larger.
One model — a senior engineer who reports to you and owns the outcome. The only real fork is who runs the production environment. Not how many people are on the work: a team can start as one engineer.
| Engineering fee — 2 senior engineers, full-time, at $7,200 each | $14,400 |
| 70% to the two engineers doing the work | $10,080 |
| 10% to your Account Owner — one of those two engineers, paid after you pay | $1,440 |
| 20% to the company — recruitment, retention, legal, infrastructure | $2,880 |
| Production responsibility — 10% of the engineering fee Named production access, changes and rollbacks, business-hours incident response. Split between the company (insurance, compliance, access management) and the engineers who handle incidents. Not part of 70/10/20. | $1,440 |
| Monthly total | $15,840 |
| Optional out-of-hours coverage — quoted separately based on the coverage you need A fixed monthly standby fee agreed before we start; incident hours outside business hours billed at overtime rates on top. | Quoted separately |
Every one of these started small.
Not one of these began as a big contract. They started as a single engineer on a first project — and grew, over years, into the work you see here. The model rewards clients who start small and stay long.
If your question isn't here, email hello@core70.com and we'll answer it directly.
Because engagements are shaped by real variables — seniority, stack, region, engagement length. A rate card would force us to quote the top of the range to everyone, or commit to numbers we cannot honestly deliver on. The range above is the honest answer: this is where the majority of our engagements land.
When the role requires an engineer based in a higher-cost market, or when seniority exceeds what the main range supports (lead architect, principal engineer). Both are uncommon. We will tell you in the first conversation whether your request is in or out of the main range.
The engineer's time, technical delivery, and the coordination, delivery management, and quality assurance the engineer handles directly — not a separate project manager or QA layer billed on top. Also included: the infrastructure for collaboration. Not included: third-party licenses, cloud spend passed through at cost, and travel if the engagement requires on-site presence.
Holding named access to your production environment, deploying and rolling back through an agreed pipeline, and responding to incidents during business hours — with an Account Owner who is full-time on your work and accountable for it. What you are buying is named people, written procedures and response targets. Where your procurement needs formal service levels, we set them with you against the systems we take on rather than publish a generic percentage. Out-of-hours standby is priced separately, only where you need it.
The 70/10/20 structure already builds long-term continuity into the default pricing. We do not discount the 70% — that goes to engineers whose cost does not fall with scale. Where scale produces efficiency is in the 20% overhead layer, and those efficiencies are passed through as a matter of course, not negotiated.
There is no minimum term. Standard notice is thirty days on either side, at any time. If you need to scale down or pause, the flexible team model — which in some of our engagements has moved between five and twenty engineers depending on season — is designed for exactly that.
If what you want is a single fixed number, delivered once, with no intention of building a longer relationship — a fixed price can give you that, and there are firms who do it well. We're probably not the one. That's genuinely okay.
But if you're open to starting small and seeing how we actually work — an engineer who talks to you directly, owns the outcome, and tells you the truth about your software — then we'll earn your trust the only way it can be earned. With real work.
That's the whole idea. Trust isn't promised in a contract. It's built, one project at a time.
One business day. Just a real number inside the range above.