Insights: Knowledge transfer in a Forward Deployed Engineering engagement
What a delivery team should pass on, when that starts, and how to tell that it has happened.
Summary: The short answer
Knowledge transfer in a Forward Deployed Engineering (FDE) engagement is not a meeting at the end. Knowledge transfer is an output planned from the start and carried out while the work is under way. It covers documentation, technical understanding and working practices, and observable signs show whether it has happened.
Transfer is the means; the aim is capability. Capability building is strengthening a client's internal teams, knowledge and systems so the organization can operate and evolve its solutions itself.
Logevon is a technology consulting and software engineering company. Logevon works in the Forward Deployed Engineering (FDE) model, so this article is written from that position. It describes Logevon's own method within the Forward Deployed Engineering model and cites no outside studies.
Definition: What knowledge transfer is
Knowledge transfer
Knowledge transfer is the deliberate handover of documentation, technical understanding and working practices from the delivery team to the client's internal teams.
- Documentation: what the system is, why it was built that way and how to operate it.
- Technical understanding: the ability to reason about the system and change it safely.
- Working practices: how changes are tested, released and reviewed.
Handover is the point at which responsibility for operating and changing a solution passes from the delivery team to the client's team. Knowledge transfer is what makes that point safe to reach.
Timing: Why transfer at the end does not work
In Logevon's view, transfer left to the end does not work because by then the knowledge has already settled in the wrong place.
The knowledge stays with people.
Decisions made during the work live in the heads of those who made them, and those people are about to leave.
The documentation is detached from the work.
Documents written after the fact describe the system as remembered, not the reasons behind it.
There is no time left to ask.
The questions that matter arise once the client's team changes the system; a final session leaves no room for that.
Process: What transfers at each stage
Something passes to the client's team at every stage, not only in the fifth. The six stages of Logevon's FDE delivery model are Understand, Assess, Design, Build & Integrate, Enable & Transfer, and Improve.
Understand
Your people and Logevon's engineers describe the problem together, so the reasoning behind the problem statement is shared from the start.
You getA written problem statement, and the reasoning behind it.
Assess
The assessment is worked through with your team, which sees the options that were weighed and why some were set aside.
You getA documented assessment your team can explain.
Design
Your team reviews the architecture and its trade-offs before anything is built, and the handover is defined in the plan.
You getAn architecture and delivery plan, with the main decisions recorded.
Build & Integrate
Your engineers build in the same codebase, so understanding of the code grows with the code.
You getWorking software your team has helped to build.
Enable & Transfer
What was shared along the way is completed and checked: documentation is finished, and your team operates the solution while we are still present.
You getArchitecture and operations documentation, and a team that has done the work.
Improve
Your team leads the changes that follow measurement, and Logevon's involvement is reduced.
You getResults measured against the goal, and a backlog your team owns.
Checklist: What to hand over
In Logevon's view, a complete handover covers six items, each with a named client-side owner.
| Item | What it is for | Owner after handover (example) |
|---|---|---|
| Architecture decisions | Explains why the system is built the way it is | Technical lead |
| Operating procedures | Steps for running, monitoring and recovering the system | Operations team |
| Interface documentation | What each integration carries and how errors are handled | Team that maintains the integrations |
| Test and release process | How a change is verified and put into service | Engineering team |
| Open backlog | Known issues and next improvements, in priority order | Product or process owner |
| Access and credentials | Who can reach which environment, repository and account | System administrator |
The roles are examples; what matters is that every item has an owner by name before handover.
Evidence: How to tell it has happened
Knowledge transfer has happened when the client's team does the work without the delivery team, and that can be observed.
Signs to look for
- The team has made and released a change without help.
- The team has resolved an incident by following the operating procedure.
- A team member who was not involved can find their way using the documentation.
- The team can explain why a main design decision was made.
- Questions to the delivery team become fewer and more specific.
These are indicators, not guarantees; check them before handover, while there is still time to close a gap.
Conditions: What it asks of the client
Knowledge transfer asks the client for people, time and authority; without them there is no one to transfer to.
- Named people who will own the solution, known from the start.
- Time set aside for them to take part, not only to attend reviews.
- Authority for them to make decisions about the system.
- Continuity: the same people through the work, as far as possible.
How much each delivery model asks of the client is compared in Forward Deployed Engineering vs staff augmentation.
Limits: The limits of knowledge transfer
Knowledge transfer has limits, and planning does not remove them.
What transfer cannot do
- Not all knowledge can be written down; some passes only by working together.
- When people leave the client's team, the transfer has to be repeated for those who replace them.
- Logevon may continue to support a client after handover when that is needed; ongoing dependency is not its business objective.
FAQ: Questions about knowledge transfer
What if we have no internal software team?
Without an engineering team, who will own the software and how handover will work are agreed at the start. Logevon can continue to support the client when needed; permanent dependency is not the goal. The Custom Software Engineering page covers this case.
How much documentation is enough?
Enough for someone who was not involved to operate the system and make a change safely. In Logevon's view that means the decisions and their reasons, the operating procedures and the interfaces, not a description of every line of code. The test is use: a team member follows the document and succeeds.
Who keeps the code and the documents?
The client keeps control of its code, data and intellectual assets, per the agreed terms. The terms are set out in the contract for each engagement.
Sources
This article cites no external sources. It rests on Logevon's glossary definitions, what follows from them, and Logevon's own method and view where marked.