How Semiconductor Teams Preserve Critical Knowledge
Critical knowledge can disappear when key engineers leave or systems change. This article shares practical ways semiconductor teams preserve that knowledge, from living state files to outage rehearsals and code-side documentation. Insights from industry experts show how to capture decisions, lessons, and context before they are lost.
The perspectives in this article were written by the named contributors and submitted through Connectively. Connectively's automated system selected them and used AI to write the headline, introduction, section headings, summary sections, and illustration, and to make minor edits for clarity. Articles are assembled and published automatically. Report errors to corrections@connectively.us. How we make our content
AZ
JH
RL
VS
RM
Maintain a Living State File
Lilach BullockAI Implementation Consultant and Fractional CMO, Lilach BullockThe practice that stops my team repeating old mistakes is a living state file, where every workstream closes with the last decision, the unfinished point and the first next action written in it. I'd also record what was tried and failed and why, so a newcomer can see the dead ends before repeating them. Update the file when the work closes rather than weeks later, because the detail fades fast. For a team, have the person who closed the work write the entry. Every new starter should read the whole file in their first week before they touch anything.
Rehearse Past Outages in Staging
Ace ZhuoCEO | Sales and Marketing, Tech & Finance Expert, TradingFXVPS1. Handover documents rot. TradingFXVPS server monitoring alerts link to runbooks for the last person to deal with the problem. A 40 page wiki for handover to cover basics doesn't get opened at 3am when the server is crashing. The TradingFXVPS way to cover for this is for knowledge to fail where knowledge fails. So every config change is committed to git with a reason for the change in the commit message, not a dry description of what was changed. A lesson that a senior engineer learned about a specific NIC driver dropping packets under MT5 stress load was then baked into provisioning scripts as a guardrail. He implemented it as he read about it, and then moved on. It was there to cover for his experience.
2. Outage replay drills. Once a month a newer engineer reproduces a past failure on a staging environment. He has all the logs and symptoms of the original failure but no additional hints. For example, we replayed a disk I/O stall failure that had frozen all trading terminals during an NFP release. A newer engineer would then re-diagnose the problem and the original engineer who wrote the fix would then monitor him in silence until the fix was complete. The two of them would then compare notes on what he did wrong and how he could have done it better. Reading a post-mortem takes about 10 minutes and is then completely forgotten 10 days later. Reproducing the failure itself sticks in their heads much better. We have already caught two nearly identical failures that would have caused problems in production: a scheduled script that would have rebooted a node in the middle of a live session of MT5, for example.
Keep Departing Experts in the Room
Jens HagelFounder & Owner, kjelloI founded an IT firm in Hamburg, and the practice I trust most is keeping the person who is leaving in the room. A freight company with 14 office staff relied on a single outside IT contractor who wanted to retire, and the passwords looked like "Apfel123". We ran the switch as a gentle handover together with that contractor, so their knowledge came across while they were still around. The managing director told me afterwards: "The best thing is that I don't hear anything about IT any more."
Jens Hagel, Founder & Owner, kjello (Hamburg, Germany)
Capture Decision Context With AI
Runbo LiCEO, Magic Hour AII'm Runbo Li, co-founder and CEO of Magic Hour. The core problem isn't that knowledge walks out the door. It's that most teams never turn knowledge into a system in the first place. They rely on tribal memory, which is just a fancy way of saying "hope the right person is in the room when the question comes up."
The practice that changed everything for us is what I call "decision logs with context." Every significant decision we make, whether it's a model architecture choice, an infrastructure tradeoff, or even why we killed a feature, gets documented with three things: what we decided, what we considered and rejected, and why. That third piece is the one everyone skips, and it's the only one that actually matters.
Here's why this works. Early on, David and I were iterating fast on our video rendering pipeline. We hit a performance bottleneck and spent two days debugging before realizing we'd already solved a nearly identical problem three months earlier with a different model. The fix was sitting in a Slack thread buried under thousands of messages. That was the moment I said, "We're never losing context again." We started logging every meaningful technical decision in a shared system. Now when either of us, or any tool we're using, encounters a similar problem, the reasoning is retrievable in seconds.
This applies directly to semiconductor teams, where the stakes are higher and the iteration cycles are longer. A fab process decision made in 2019 might not surface as a mistake until 2024. If the "why" behind that decision isn't documented, the new team will either repeat the error or waste months reverse-engineering the rationale.
The real unlock is that AI makes this 10x easier now. We use AI to summarize technical discussions, tag decisions by category, and surface relevant past decisions when new ones are being made. It turns a passive archive into an active co-pilot.
Knowledge preservation isn't a culture problem. It's a tooling problem. Build the system, and the culture follows.
Log Choices Beside the Work
Victor SmushkevichFounder, Tested MediaThe practice that pays off most is a short written decision log kept next to the work itself. Each entry holds the choice made, the options rejected, and the reason in plain language. I run a marketing agency, so I can only speak to small technical teams, but the failure pattern looks the same anywhere experienced people leave.
When a senior person walks out, the steps survive in a checklist. The reasons behind the steps leave with them. A new hire sees an odd step, assumes it's legacy clutter, removes it, and the old mistake comes back. A log entry that says what broke and why stops that in about ten seconds.
The second habit is a one-page review written by whoever did the work, within a week of a project closing, while the details are still fresh. New people read the last ten before they touch anything. In my experience that teaches more than a week of shadowing, because shadowing shows you what people do and the reviews show you what they stopped doing.
When someone is leaving, I'd also have them record themselves walking through their trickiest procedure. The questions a newcomer asks while watching it are usually the missing log entries.
Document Traps Near Code
Richard MeadowsHead of Content, StreamriseWe are a software team, not a chip team, so take this as a transferable practice rather than a semiconductor-specific one.
The practice that has paid off most is a written list of traps kept next to the code. Each entry is one thing that bit us once, and each has the same three parts: what looked reasonable, what actually happened, and how to recognise it next time. It is written by whoever got hurt, while the memory is fresh.
A concrete entry. On 8 August 2026 our dashboard stopped loading. 24 queries were hanging, the oldest for 878 seconds. The cause was a one-line schema change (ALTER TABLE ... ADD COLUMN IF NOT EXISTS) that several modules ran at every start-up. It takes an exclusive lock even when the column already exists, it queued behind a long backup transaction, and in PostgreSQL every reader of that table then queues behind the waiting lock. One harmless-looking line stopped everything that read the table.
The trap entry records the mechanism, the diagnostic query that finds the blocking chain, and the rule that came out of it: schema changes run only when a column is actually missing, with a 3-second lock timeout, so a failed attempt gives up instead of stalling production. A new engineer reading that entry learns in a minute what took us a long incident to find.
Why this beats documentation of how the system is meant to work: a design document tells you the intended behaviour, while a trap list tells you where reality disagreed with it, and that is what repeats when people leave.
What I cannot offer is a measured effect on repeat incidents. We did not count them before and after, so treat this as a practice we keep, not a proven reduction.