A dedicated developer is a retained seat, not a pool
The code is yours from day 1, living in your repositories and deploying to your cloud accounts. A standup every working day, held in your hours.
Tell us what the role has to own
A shortlist typically comes back within a few days. If nobody on the bench matches the role, we say so and recruit for it.
Where this usually starts
The seat has been open since last quarter
You promised a roadmap to a board, an investor or a customer, and the distance between that promise and the empty chair is the part that actually keeps you up. The search ran past the quarter it was budgeted for. The candidates who cleared the bar took counter-offers, and the roadmap has not moved since.
You have bought this before
A freelancer was juggling three clients, so the work arrived in bursts and there was no second number to call when they went quiet. Or you were sold a team and got rotation, the person who understood the codebase moved to another account, and you paid a second time for the same context to be learned again.
You will be reviewing whatever this person writes
You have absorbed an outsourced software engineer before who was net negative for two months and nobody said so, and the review load landed on your evenings on top of your own work. The commercial decision is probably already made, so what you want is enough specific detail to sign off honestly or say no with a reason.
What an engagement looks like
One retained software engineer
3 months or longer, typically
What it includes
- A retained seat. Not a shared pool, not a rotation, and not someone billing you between two other clients
- A standup every working day, held in your hours, with the time set at scoping
- Your code, your repositories and your cloud accounts, settled from day 1
- An NDA from day one, and access through SSO
Widens when The work being continuous rather than a scoped piece. Three months is where the productivity curve from any new developer flattens, so length follows the work rather than the contract.
The pilot, before the engagement runs
3 weeks
What it includes
- Evaluation criteria written into the engagement before the developer starts
- A replacement if the criteria are missed
- The pilot re-run with the next candidate against the same written bar
Widens when Nothing widens it.
A software engineer plus DevOps or QA
Scoped to the work
A different engagement, and we say so rather than absorb it
What it includes
- At least one DevOps and one QA engineer alongside the developers on full-team buildouts
- Scoped around developers only where that is genuinely all the work needs
Widens when Whether releasing and testing have to be held beside the building rather than by you.
How long the search you are already running actually takes
SHRM's 2025 benchmarking puts the average time to fill a role in the US at about 44 days. Workable reports about 62 days for an engineering role globally. Those are two publishers over two different populations, so they sit beside each other rather than being subtracted from one another. Either way the chair stays empty for the whole of it, and the roadmap does not move while it is.
Show data table
| Item | days to fill the role |
|---|---|
| An average US role, all roles (SHRM 2025 benchmarking) | 44 days |
| An engineering role, global (Workable) | 62 days |
Two published figures, two different populations: 44 days for an average US role, 62 for an engineering role globally.
What the same clock looks like on this side
Three numbers, and where each one comes from.
Atyantik, stated engagement practice
Atyantik, stated engagement terms
Atyantik, self-reported count
The definition
Dedicated, in four parts
The arrangement
A retained seat, not a shared pool
Not a rotation, and not someone billing you between two other clients. We do not run a monitoring dashboard or a timesheet audit. It is the difference between this and a freelancer working three accounts, or an agency that moves that person elsewhere.
How it runs
When you get to talk to someone
Ask what happens at 9am your time. A standup runs every working day in your hours rather than ours, with the lead on it for about thirty minutes. We work IST 10:00 to 19:00, and the time is set at scoping before anyone starts.
Settled before signing
Code and IP are yours from day 1.
The work lives in your repositories and deploys from your cloud accounts. The documentation is yours, and on offboarding you keep all of it, including the operational runbook. NDA from day one, SSO and secure repository access.
Settled before signing
Criteria agreed before the developer starts
The bar is agreed while nobody yet has a reason to argue about it. A trial is easy to offer; what it is measured against is what makes it mean anything. Ask us what the bar is, and ask everyone else bidding.
If the person falls short
You are back at the beginning, running the search again, another month gone.
The criteria do not move between candidates. The second pilot is measured against the same written bar as the first, which is what stops a replacement from quietly becoming a lower standard.
What we commit to
The developer is replaced and the pilot re-runs with the next candidate.
The shortlist is full of near-misses and somebody sends one anyway.
It is slower to say the bench does not match, and a near-miss costs you the pilot, the calendar and the conversation you have to have afterwards.
What we commit to
If our bench does not match what the role needs, we say so and recruit for it rather than sending the closest person we have.
What happens if they leave
We replace a developer whose start goes wrong, against the criteria agreed before they began. For someone who leaves after a year we have no written policy, and we are not going to invent one. People leave jobs, and that is true of a seat you own as much as a seat you retain. What you keep either way is everything the work produced.
How an engagement runs
01
The brief
You tell us what the role has to own: the product, the stack, and the direction the work executes against.
You get
A written role scope, and the standup time set with it
02
The shortlist
Within a few days you get candidates our own technical team has already put through its own bar. Run your full hiring loop on them, run one technical call, or run none. All three are supported and none of them is awkward to ask for.
You get
Candidate profiles, and an interview slot whenever you want one
03
The pilot
Three weeks against the criteria already written into the engagement. Every change goes through code review by a senior software engineer, and CI gates the merge before anything lands.
You get
Reviewed, merged work in your repository, and the written criteria to judge it against
04
The engagement
A retained seat, so the context stays in one place instead of being relearned by whoever is free that month. GitFlow with unit and integration tests behind every merge, and architecture decisions written into the TRS as they are taken rather than reconstructed later.
You get
The documentation and the operational runbook, yours, and you keep all of it on offboarding along with the code, the repositories and the deployments
Before you take this to procurement
Can we interview them ourselves?
- Run your full hiring loop, run one technical call, or skip interviews entirely.
- Every developer we put in front of you has already been through our own technical team first.
- If the shortlist does not produce the right fit, another one comes.
- If our current bench does not match what the role needs, we tell you that and recruit for it.
Who owns the code?
Is there a minimum commitment?
When do we actually get to talk to them?
How quickly can someone start?
One retained software engineer, or another model
Who on your side owns the technical direction this person executes against?
| One retained software engineer | A dedicated team of software engineers, testers and designers | Extend the team you already have | Software engineers plus the delivery management to point them | |
|---|---|---|---|---|
| Choose this when | One retained software engineerThere is an existing product with a roadmap, the constraint is sustained capacity rather than a burst, somebody on your side already owns the technical direction, and the work runs continuously for months. | A dedicated team of software engineers, testers and designersThe thing does not exist yet and has to be designed, built, tested and shipped at once, or front end, back end and infrastructure all have to move in the same weeks. | Extend the team you already haveYou already run a functioning engineering team with its own process, the gap is throughput inside that process rather than ownership of a product area, and your own leads will direct the work day to day. | Software engineers plus the delivery management to point themNobody on your side has the time to direct the work, or you want scope, quality and timelines held by somebody other than you. |
| It costs you | One retained software engineerOne accountable name, and one throughput. Anything that has to happen in parallel waits its turn behind whatever they are doing. | A dedicated team of software engineers, testers and designersA delivery relationship to hold. One person here is a serial bottleneck, and what breaks is the calendar rather than the headcount. | Extend the team you already haveYou keep the management load, because that is the part you were not trying to hand over. | Software engineers plus the delivery management to point themYou pay for the management layer as well as the building. A retained software engineer with nobody to point them is the most expensive way to buy nothing. |
Tell us what the role has to own
We typically come back with a shortlist within a few days, and a start is often immediate once you pick someone.
Send the product, the stack, the direction the work has to execute against, and the hours your own working day runs. That is enough to start, and enough to set the standup time.
Two things can come back. A shortlist our technical team has already put through its own bar, typically within a few days, with a start that is often immediate once you have chosen someone. Or, if nobody on the bench matches the role, we say so and recruit for it. Asking costs nothing and commits you to nothing.
- Everything you share stays private, NDA from day one
- Code and IP yours from day 1, in your repositories and your cloud accounts
- The daily standup held in your hours, with the time set before anyone starts