5 ways to prevent knowledge from being lost in product development

Nothing is more frustrating than encountering a problem again that you thought had been solved. Or to have wasted days on a problem only to realize that it has long since been solved in a different context.

One consequence of increasing complexity is the problem of not only accumulating knowledge but also retaining it in such a way that we can find it when we need it.

One analogy is the comparison with data, which we first have to process in order to obtain real information. In the same way, we have to manifest knowledge in order to be able to act on it.

Approaches to manifesting knowledge

Fortunately, it is not that difficult to manifest knowledge. However, we have to make an advance contribution. It is therefore important that decision-makers provide enough resources for this and that employees see the sense in this task.

1. document knowledge

Capturing knowledge in writing is the obvious way to manifest knowledge. But a document stored on Sharepoint is only useful if potential users have a chance of finding it there. In particular, it is dangerous to rely on the search function (or now AI search).

Instead, we should document in a suitable system. This can indeed be Sharepoint or Confluence. However, it is more important that the content is structured, maintained and integrated into the work processes. This is the only way to ensure that knowledge does not become a "data dump" but an active tool that supports decision-making and action.

• Ensure ownership: Who is responsible for retaining knowledge? How do we live the life cycle? What is the motivation to do this continuously? This should be anchored in the employees' objectives and measured. This is common practice in software development, e.g. tracking the average age of bugs.
• Question and answer database: Systems like Stackoverflow for teams record knowledge in the form of questions and answers and facilitate updating by the team.
• Networked Notetaking: In tools such as Logseq or Obsidian we capture knowledge in an unstructured way and use it in the form of a knowledge network connected by tags. This is more suitable for your own knowledge management, but can also be used in a team.
• Models or specialized notations: Some knowledge can be captured much better in a separate notation to enable data to be found and utilized. The spectrum ranges from tables (Excel) for tabular data, YAML or JSON for structured data such as parameters that are to be processed automatically or SysML models,

2. organize and curate knowledge

No matter where we store our knowledge, we need to curate it. This is more important than ever, because the amount of data is exploding. Unfortunately, this doesn't happen on its own, and even AI is only able to take on this task for us to a limited extent, at least at the moment.

We should make sure that our tools have the following features to organize the information:

• Tags: Tags are an extremely powerful tool for organizing information so that we can quickly find what we are looking for. However, tags must be well maintained and well supported by the tool. Tool support in particular is often neglected.
• Hierarchies: Hierarchies are the classic way to organize knowledge, but they require a lot of discipline for large amounts of knowledge.
• Search and filter functions: In addition to tags and hierarchies, powerful, context-sensitive search and filter mechanisms are crucial to making knowledge actually usable.
• References / Traceability: A good tool makes it possible to reference other content. These can be classic links, whereby the data management must be robust with regard to renaming.
• Ontologies: Ontologies require some preparatory work, but can pay off depending on the context. They create a common vocabulary and clear relationships between terms, which reduces misunderstandings and enables the automatic processing of knowledge, especially in large, interdisciplinary projects.
• Intranet: Even if it is "low tech", a clearly defined entry point for searching for knowledge is hugely effective in helping employees find what they are looking for.
• Versioning: We humans tend not to want to delete anything. But this leads to outdated information and redundancy. Good versioning takes away the fear of deletion and can prevent redundancy if we want to keep outdated information "in the archive".
• Visualization & navigation aids: Graphical overviews (knowledge graphs, heat maps, dashboards) make it easier to understand connections and identify gaps.

3. make knowledge executable

An exciting way to manifest knowledge is to perpetuate it in artifacts that can be executed in some form. A best practice in software development, for example, is to first write a unit test for a new bug before fixing it. Should the same bug reappear at some point, the unit test would find it.

If a unit test is first written for a bug before it is fixed, the knowledge about the bug is permanently manifested in the test and a recurrence is reliably detected.

Here are a few ways in which we can make knowledge executable:

• Unit tests: We can record not only bugs, but also other knowledge about our code via unit tests
• Modules: Reusable "modules" prevent reinventing the wheel. What a module is depends on the context: a software library, a physical component, etc. To effectively build a module library, we need a suitable architecture.
• Design Patterns: Due to the complexity of modern systems, creating modules is not always practical. However, it is possible to identify recurring patterns that represent best practices. Recording design patterns is time-consuming and requires maintenance and regular training of employees.
• Adapt processes and checklists: Processes are also executable knowledge and are often supplemented with checklists. This is sometimes overlooked when maintaining knowledge.

In software development, "X as Code" (e.g. "Configuration as Code") has become established in order to make knowledge executable. In principle, this is also possible in systems engineering.

4. share knowledge

Knowledge is not an end in itself, but should help the team to process tasks efficiently and avoid detours. That's why we can't do without knowledge transfer through people.

• Formalize knowledge transfer: This includes pairing or brown-bag sessions, i.e. giving informal talks over a meal. We can also easily record these. In this case, it is important to provide the videos with appropriate metadata so that interested parties can find them.
• Analyze historical data regularly: Findings from past projects, tests or error databases should not gather dust, but should be reviewed together at regular intervals. This allows patterns to be recognized, best practices to be derived and new team members to be trained more quickly.
• Code & Model Reviews so that knowledge does not just remain in the heads of individuals. Reviews promote shared understanding, uncover gaps and make implicit knowledge explicit.

5. and AI?

AI will help us deal with increasing complexity and make knowledge more accessible, but it is not a panacea. Here are AI approaches that can help us retain knowledge:

• Automatic transcription & summary: Meetings, telephone calls and workshops are now routinely recorded, transcribed and condensed into structured minutes or decision lists. Nevertheless, we still have to integrate this content into our knowledge management system.
• Semantic enrichment: AI can enrich texts with tags, categories or ontologies so that content can be found more easily later, thereby increasing the efficiency of the curation process.
• Knowledge extraction from documents: Unstructured sources (PDFs, specifications, emails) can be analyzed much more easily and converted into structured knowledge.
• Chat Interfaces: More and more tools are providing chat interfaces that can have a similar value to a question-and-answer database.
• Automated consistency check: AI checks documents, code or models for contradictions, duplicates or outdated information and suggests corrections.

Conclusion

Retaining knowledge correctly is important, but it doesn't happen on its own, not even with AI. To avoid reinventing the wheel, organizations must have a strategy for knowledge management, use the right tools and provide sufficient resources. However, when used correctly, good knowledge management can represent an enormous competitive advantage.