Why Conseiltek · Forward deployed
Engineering at the point of impact.
Traditional consulting recommends a transformation. Traditional staff augmentation supplies capacity. We put a named senior engineer next to the business problem and ship the outcome with you. Below is what that means in practice: what a Forward Deployed Engineer is and is not, the loop they work in, how delivery runs, the three commercial models, and the week-by-week shape of a typical eight-week replacement.
The model
A Forward Deployed Engineer is a senior engineer, deployed forward.
The term comes from firms that put engineers inside the customer rather than behind a statement of work, and it is worth being precise about it, because it has been borrowed by a number of organisations who mean “consultant” and are hoping you will not check.
What it is
- A senior engineer who writes code in your repository, in your branching model, reviewed by your team.
- Someone who learns your domain until they can argue with your domain expert and sometimes win.
- Accountable for the outcome — the system working in production — rather than for hours booked.
- Able to make architectural decisions in the room, and to write down why, without raising a change request.
- Introduced to you by name before you sign, and replaceable on two weeks notice if the fit is wrong.
- Backed by the whole firm: Techtons, the reference architectures, and specialists they can pull in for a week.
What it is not
- An account manager. Nobody on the engagement has a sales target attached to your renewal.
- A coordinator who books work with a delivery centre in another timezone and reports on it.
- A junior on a bench being trained at your expense, with a senior name on the statement of work.
- A contractor who takes a ticket, closes it, and leaves the reasoning in their own head.
- A permanent fixture. If we are still indispensable in year two, we have done the job badly.
The practical test is simple. Ask who writes the code, ask for their name, and ask what happens to the engagement if that person is wrong about something. If the answers are “a team”, “we will confirm at kickoff” and “a change request”, you are buying a delivery centre with a nicer word on the invoice.
The loop
Embed. Understand. Prototype. Integrate. Productionize. Measure. Iterate.
Seven steps, and the last one is why the first six are worth doing. An engagement that stops at the demo has produced a demo.
01
Embed
In your repository, your standup and your incident channel, next to the people who do the work.
02
Understand
Learn the actual workflow from the operators, not the process document. Argue with the domain expert until the model is right.
03
Prototype
Something running in days, against real data, so the conversation is about a system rather than a slide.
04
Integrate
Connect the enterprise systems, identity and data that the workflow actually touches, including the ones missing from the diagram.
05
Productionize
Security, observability, tests, runbooks and a deployment path. The demo and the production system are the same repository.
06
Measure
Adoption, cycle time, cost and quality. If the number does not move, the engineering did not land.
07
Iterate
Keep going after launch. The first version is a hypothesis about the workflow, and workflows answer back.
Principles
- Start with the workflow.
- Work with actual users.
- Ship early.
- Integrate with reality.
- Own production outcomes.
- Measure value.
- Build reusable foundations where appropriate.
- Transfer knowledge.
- Maintain engineering quality while moving quickly.
How delivery runs
Discover. Prove. Deploy. Scale.
The delivery sequence, distinct from the three commercial models below. Discover to Scale is how the work runs; Guide, Join and Deliver are how you contract for it. Any commercial model can carry any stage.
01
Discover
Map workflows, systems, spend, pain points and opportunity.
Two weeks, fixed price, ending in a document you keep whether or not you continue: what the incumbent costs, what you use, where the manual work sits, and which opportunity is worth taking first.
02
Prove
Build a focused prototype or production slice that validates the technical and the economic assumptions.
One slice, deployed, against real data and real users. If the assumptions do not hold, this is where you find out, and it is the cheapest place in the whole sequence to find out.
03
Deploy
Integrate with enterprise systems, security, data and operations.
Identity, downstream systems, the data migration, the parallel run and the cutover. Production is the point at which the work counts, so it is planned from week one rather than appended.
04
Scale
Expand the capability, harden the platform, drive adoption, and identify the next replacement opportunity.
Adoption measured in changed workflows, the platform hardened against what production has taught us, and the next candidate chosen from evidence rather than from the renewal calendar.
How you contract
Take the blueprint, borrow the engineer, or hand us the outcome.
Three commercial models, not three delivery methods. The same people and the same code in all three. What changes is who holds the keyboard, and how much of the risk sits with us.
Guide
You have a dev team. We hand them the blueprint.
Reference architecture, the code, the infrastructure-as-code, the migration plan and a weekly working session with the engineer who built it. Your team does the building. We make sure they are not discovering the hard parts in production.
What is included
- Full reference implementation under Apache-2.0
- AWS Terraform and Azure Bicep, both maintained
- Architecture review and written ADRs
- Weekly 90-minute working session with an FDE
- Migration runbook and rollback plan
- Async access to the engineering channel
Fixed monthly. 3-month minimum.
You have engineers and you want the blueprint, not the builders.
Join
Hire a Forward Deployed Engineer. They sit in your team.
One of our engineers joins your standup, your repo and your on-call rotation. They are measured on your outcome, not on hours booked. They write code in your codebase from week one and leave documentation behind them.
What is included
- A named senior engineer, not a rotating bench
- In your repo, your standup, your Slack
- Everything in Guide, plus hands on keyboard
- Pairing and code review that upskills your team
- A written handover from day one, not day last
- Replaceable on two weeks notice, either direction
Monthly per engineer. 3-month minimum, 30-day exit.
You have engineers, but not the specific depth this needs.
Deliver
We take it end to end and hand over the keys.
Discovery, build, migration, cutover, production run, handover. We own the outcome and the date. At the end you get the repository, the infrastructure, the runbooks and a team trained to run it, or we keep running it for you.
What is included
- Fixed scope and a fixed date, agreed before we start
- A pod: FDE lead, engineers, and a platform engineer
- Data migration from the incumbent, with reconciliation
- Parallel run and a rehearsed cutover with rollback
- 30 days of hypercare after go-live
- Optional Run agreement: we operate it, you own it
Fixed price per phase. Run priced separately.
You want the outcome, not the project.
Most clients start at Guide or with a single Discover, and move to Join or Deliver once they have seen how we argue about a parity matrix. Moving between models does not restart anything — it is the same engineers and the same repository throughout. See all four core offers →
Delivery, week by week
Eight weeks to cutover. Thirteen to handover.
This is a typical Deliver engagement for a mid-complexity system with a team of two to four. Larger systems take longer and the Techtons entry for each application carries its own honest estimate. What does not change is the order, and in particular that the data migration is rehearsed in week 6, before anyone has committed to a cutover date.
- Week 1
Discovery
We read the incumbent rather than the sales deck: usage telemetry, the admin export, the permission model, and interviews with the five people who actually live in the tool. We also inventory every integration in and out, using network and vendor audit logs rather than the architecture diagram, because the diagram is always out of date.
Usage profileIntegration seam inventoryData volume and quality readNamed decision-maker agreed - Week 2
Parity definition
The single most important week. We write the parity matrix — every capability, what the incumbent does, what we will build, and what we will explicitly not build. The last column is the one that matters. It is signed by your decision-maker before a line of application code is written, and it is what we demonstrate against every week thereafter.
Signed parity matrixExplicit out-of-scope listTarget architecture, AWS and AzureCutover criteria defined - Weeks 3 to 5
Build
Three weeks of building, starting from the Techtons reference implementation rather than from an empty repository, which is most of the reason this takes weeks instead of quarters. Deployed to your non-production environment on day one of week 3 and redeployed continuously after that. A demo every Friday against the parity matrix, not against a burndown chart.
Working system in your cloud accountTerraform or Bicep for every environmentCI/CD with rollbackWeekly parity demo - Week 6
Migration dry run
The full extraction and load against a copy of production, timed end to end, with a reconciliation report reviewed line by line with your data owners. This is where the encoding problem, the soft-deleted records and the custom field two teams use differently all surface. It is scheduled here deliberately, while there is still time to react.
Reconciliation reportTimed migration windowData exception list with ownersGo or no-go on the cutover date - Week 7
Parallel run
Both systems live, the incumbent still authoritative. A pilot group works in the new system, data flows into both, and a difference report is produced daily and read by a human. Nothing about the cutover decision is a judgement call — the criteria were written in week 2.
Daily difference reportPilot group feedback closed outRunbook rehearsed at least onceRollback path tested, not just written - Week 8
Cutover
A rehearsed runbook, a named go or no-go decision-maker, and a rollback that has actually been executed in the dry run. Usually a weekend, sometimes a quiet evening, occasionally staged by business unit. The incumbent licence stays live until the end of its term — we do not ask you to cancel it on cutover day.
Production cutover completeFinal reconciliation signedIncumbent in read-only, not cancelledSupport path switched to us - Weeks 9 to 12
Hypercare
Thirty days on your incident channel with a response time in the contract. We fix what breaks, we tune what is slow, and we spend the rest of the time writing down what we know while it is still fresh. Every incident produces a runbook entry, and the runbook entries are the handover.
Incident response with agreed SLOsRunbooks written from real incidentsPost-incident reviews published to youBacklog of known rough edges, prioritised - Week 13
Handover
Your engineers ship the next three changes with ours watching rather than typing. Then the walkthrough: architecture, decision records, runbooks, on-call, cost model and the list of things we would do differently. The engagement ends when your team ships without us, or converts into a Run agreement if you would rather we operated it for a while.
Three changes shipped by your teamADRs and runbooks handed overOn-call and ownership namedExit plan or Run agreement signed
The three weeks that decide the project
Week 2
Parity definition. Everything that goes wrong later starts with a capability nobody wrote down as out of scope.
Week 6
Migration dry run. Data quality is unknowable in advance, so we find out early and with the incumbent still running.
Week 13
Handover. If your engineers cannot ship three changes without us, the engagement is not finished, whatever the date says.
What we need from you
Four things, and the project is roughly as fast as the slowest of them.
None of these are unusual and all of them are worth agreeing before kickoff rather than discovering in week three. Where a client cannot provide one, we would rather change the plan than pretend the date survives.
Access, in week one
Repository, cloud account, identity provider, the incumbent admin console and its export API. Not production data on day one — a copy is fine, and often better — but real access to a real environment. Every week an FDE spends waiting on an account is a week you paid for and did not receive.
Blocker if it takes longer than 10 working days
One decision-maker who can say no
A single named person who can approve the parity matrix, accept an out-of-scope item and call the cutover. Not a steering committee that meets fortnightly. The parity matrix is a series of decisions about what you will stop doing, and those decisions need someone whose authority is not in question.
Named before kickoff, in the statement of work
A domain expert for two days a week
Someone who knows why the process is the way it is, not just how the tool is configured. Usually the person everyone already interrupts. We need roughly two days a week of their attention for the first six weeks, and we will say so in the plan rather than discovering it in week four.
About 2 days per week, weeks 1 to 6
An environment we can break
A non-production cloud environment where we can deploy on day one and destroy on day three. If every environment change needs a ticket and a two-week lead time, that lead time is the project timeline and no amount of engineering will compress it.
Deploy on day 1, no ticket queue
Handover
We optimise for being fired.
Not as a slogan. As a structural choice that shows up in how the contracts are written, because the alternative — an engagement that becomes load-bearing — is the thing our clients are trying to escape in the first place.
The whole argument of this company is that renting software forever is a bad deal. It would be incoherent to sell that argument and then arrange to be a permanent line item ourselves. So the handover is not a phase at the end. It is a document that exists from day one, is updated every week against work that actually happened, and is reviewed in the monthly service review whether or not anyone asks.
Practically: you own the repository and the cloud account throughout, so there is nothing to transfer at the end. Architecture decision records are written where your engineers will find them. Runbooks come out of real incidents during hypercare rather than being imagined in advance. And the acceptance test for handover is behavioural, not documentary — your engineers ship three changes to the system with ours in the room but not on the keyboard.
If you would rather we kept operating it, that is a separate Run agreement priced per system per month, with a standing exit plan updated quarterly, no exit fee and no minimum beyond the first three months. It is deliberately arranged so that leaving is never more expensive than staying.
You own it from commit one
Your repository, your cloud account, your licence. There is no transfer event, no escrow and no clause that lets us take anything back.
The handover doc starts on day one
Updated weekly against real work. If an engagement ended abruptly in week five, you would still have a usable document.
ADRs, not tribal knowledge
Every decision that will still matter in two years is written down where your team works, with the option we rejected and why.
Runbooks written from real incidents
Hypercare exists partly to generate them. An imagined runbook is a document; a runbook from a 3am page is an asset.
A behavioural exit test
Three changes shipped by your engineers, ours watching. Until that happens the engagement is not finished, whatever the plan says.
A conversion path for the engineer
If you want to hire them, the fee is agreed up front and shrinks over the engagement. We would rather that than lose the client.
Objections
Eight questions we get asked, answered properly.
These are the real ones, in roughly the order they come up. Where the honest answer is uncomfortable, it is still the answer.
What happens when the FDE leaves?
Less than you would expect, because the handover document exists from day one rather than day last, and because it is updated weekly against real work rather than written in a rush at the end. Architecture decision records live in your repository. Runbooks are written from actual incidents during hypercare, not imagined ones. The last two weeks of any engagement are your engineers shipping changes while ours watch.
The blunter answer: if an FDE leaving breaks the system, we built it wrong. That is a defect in our delivery, not a reason to keep paying us, and we would rather find it in week 13 than in year two.
Who maintains this in year three?
Your team, or us under a Run agreement, and you should decide which before the build starts rather than after. This is the question we disqualify people on more than any other — if there is no team, no budget line and no on-call rotation eighteen months out, owned software is the wrong answer and a licence is the right one.
The concrete version: an application from Techtons typically needs a fraction of one engineer to keep current — dependency upgrades, framework major versions, cloud deprecations. Not zero. If your organisation cannot find that, keep renting, and we will tell you so in the assessment.
Is this just build-versus-buy again, with new packaging?
It is the same question, with two of its inputs changed. Build used to mean starting from an empty repository with an unknown estimate. Techtons entries are working reference implementations with the architecture, the infrastructure code and a published build estimate attached, so the starting point is week four of a traditional project rather than week zero. And AI-assisted engineering has genuinely moved the cost of the middle 60 percent of an application.
What has not changed is the arithmetic on the other side. Below roughly 150 seats, per-seat pricing still wins. Where the vendor attestation is the product, buying still wins. We publish those cases on every page because the honest version of this argument is a narrower one than the marketing version.
How do you go this fast?
Four things, none of them magic. We start from a reference implementation that already exists and already deploys, rather than from nothing. We define parity in week 2 and refuse to widen it, which removes the single largest source of schedule loss. Our engineers work with AI across the whole cycle — specification, code, tests, migration tooling, documentation — and we have rebuilt the delivery process around that rather than bolting an assistant onto the old one.
And we build a narrower thing. A commercial product must serve every customer; yours has to serve you. Most of what you are paying for in a licensed product is configurability you will never use, and not building it is a large part of the speed.
What if you get the estimate wrong?
Phases are fixed price, agreed before the phase starts. If a phase overruns because we estimated it badly, that is ours and we absorb it. If it overruns because the scope changed, we stop, price the change, and you decide — we do not quietly consume the contingency and tell you in week seven.
The structural protection matters more than the commercial one. The migration dry run sits in week 6, before you have committed to a cutover date, precisely because data is where estimates fail. If the dry run says the migration is a month rather than a week, you learn that with the incumbent still running and a decision still open.
Who owns the intellectual property?
You own the delivered code outright — everything written for your engagement, in your repository, from the first commit. Not a licence to use it, not a joint ownership arrangement, not an escrow. There is no clause that lets us take it back and nothing you need to keep paying to retain the right to run.
The Techtons reference implementations we start from are published under Apache-2.0 on GitHub and stay that way. That means the base is permissively licensed for you and for everyone else, including your competitors. If work we do for you improves a reference implementation in a way that is generic — a better migration pattern, not your business logic — we will ask before contributing it upstream, and no client-specific code goes into Techtons.
What about security?
Our engineers work under your access model, on your accounts, with your logging watching them. We do not take copies of production data to our own infrastructure; migration tooling runs in your cloud account and the extracts stay there. Named individuals, background checked, with access provisioned through your identity provider and removed by your leaver process, not ours.
On the systems themselves: threat model, secure pipeline controls, dependency and secrets scanning, independent penetration testing before go-live where the system warrants it. And the honest part — moving a system in-house transfers the control obligation from a vendor attestation to you. We cost that explicitly in the assessment rather than leaving it as a surprise for your auditor.
Can we hire your FDE permanently?
Yes. There is a conversion fee, it is written into the contract before you start, and it scales down the longer the engagement has run — after twelve months it is nominal. We would far rather you hire the engineer than lose you as a client, and an engineer who wants to take the role is an engineer we were going to lose anyway.
We also do not block it, discourage it in the room, or treat it as a breach. An engagement model that depends on preventing your best relationships from becoming permanent ones is a model we do not want to defend.
Still not convinced? Read a parity matrix instead of a page about us — 37 applications, with the rows where we say no.
Two weeks, fixed price, and you keep the report.
We take your single most expensive SaaS line item, establish what your teams actually use, and come back with a parity matrix, an AWS and an Azure architecture, a cost model and a delivery plan with dates. If the honest answer is keep paying the vendor, that is what the report will say.