Knowledge Management

Documentation and Company Knowledge Bases


Most businesses have knowledge scattered: processes that only one person understands, client history that lives in someone's memory, technical knowledge that walked out when the last developer left. A knowledge management system captures what your organisation knows and makes it findable, usable, and persistent. Institutional memory survives individual departures. New people get up to speed in weeks instead of months. The business stops getting dumber every time someone leaves.

When Knowledge Lives in Heads

In most businesses, knowledge accumulates in people rather than systems. Sarah knows how the invoicing workaround works. Tom remembers what happened with that difficult client in 2019. Maria is the only one who understands how the integration was set up. This knowledge is real and valuable, but it's trapped in individual minds where it can't be shared, searched, or preserved.

This creates fragility that shows up in predictable ways:

The "Ask Sarah" problem

Every question about a topic goes to the same person. They become a bottleneck. When they're busy or away, work stalls. When they leave, the knowledge goes with them. A single resignation can set back an entire department.

Training by shadowing

New people learn by following experienced colleagues, absorbing whatever happens to come up. Important but rare situations never get covered. Each new starter reinvents the wheel on common problems that were solved years ago.

Repeat mistakes

Someone solves a problem, but the solution isn't documented. Six months later, someone else hits the same problem and solves it again from scratch. You pay twice to learn the same lessons. Sometimes three or four times.

Expertise walks out

When someone leaves, their knowledge goes with them. The organisation gets dumber with every departure. Critical context evaporates. Decisions that made perfect sense become mysterious because nobody remembers why.

Documentation exists, somewhere. There's a shared drive with folders nobody's opened in years. A wiki that was abandoned after the initial enthusiasm. Reference materials that were never updated after the process changed. The problem isn't lack of documentation tools. It's that documentation isn't woven into how work happens. Without a single source of truth, information fragments and trust erodes.

The cost is real but often invisible. One study found that employees spend an average of 5.3 hours per week waiting for information from colleagues or searching for information themselves. In a 20-person company, that's over 100 hours per week spent on information friction. Some of that is inevitable, but much of it represents knowledge that exists somewhere in the organisation but can't be found or accessed.


What a Knowledge Management System Should Do

A proper system captures and surfaces what your organisation knows. It turns individual expertise into shared infrastructure that anyone can access.

  • Document processes Step-by-step guides for how recurring work gets done, maintained by the people who do the work
  • Record decisions What was decided, why, what alternatives were considered, and what happened afterwards
  • Make information findable Search and navigation that gets people to answers faster than asking colleagues
  • Stay current Ownership and review cycles that prevent documentation from going stale and misleading people
  • Surface contextually Documentation appears where work happens, not in a separate silo that nobody remembers to check
  • Capture as a byproduct Knowledge created through normal work, not separate documentation efforts that never quite happen

Knowledge becomes institutional, not personal. The business remembers what individuals might forget. New people can find answers without interrupting colleagues. The organisation's collective intelligence grows over time instead of resetting with each departure.


Knowledge Management by Business Type

Different businesses have different knowledge challenges. The core principles are the same, but the implementation varies based on what knowledge matters most and where the friction occurs.

Professional Services Firms

Accountants, solicitors, consultants, agencies. The primary challenge is client-specific knowledge: preferences, history, past engagements, key contacts. Secondary challenge is methodologies and processes that evolve through practice.

Priority areas: Client relationship records, engagement templates, methodology documentation, matter/project close-out summaries that capture lessons learned.

Manufacturing and Distribution

Production processes, equipment operation, quality standards, supplier relationships. The challenge is that knowledge often lives on the factory floor with experienced operators who learned through years of hands-on work.

Priority areas: Standard operating procedures with visual aids, equipment troubleshooting guides, supplier specifications, quality control checklists, safety procedures.

Technology Companies

Codebases, architecture decisions, deployment procedures, incident response. Technical knowledge needs to be precise and current because outdated documentation can cause outages.

Priority areas: Architecture decision records (ADRs), runbooks for operations, onboarding guides for developers, API documentation, post-incident reviews.

Retail and Hospitality

Customer service procedures, product knowledge, operational routines. High staff turnover makes rapid onboarding critical. Knowledge needs to be accessible to people who may not sit at desks.

Priority areas: Visual procedure guides, product catalogues with FAQs, opening/closing checklists, escalation procedures, customer complaint handling.

The common thread: identify what knowledge would hurt most to lose, then build systems to capture and preserve it. Start with the highest-risk areas where a single departure could cause real damage.


The Knowledge Base Structure

A central repository organised by how your team actually thinks and works. The structure should match mental models, not org charts.

By function
  • Operations: how work gets done day-to-day
  • Finance: invoicing, collections, budgeting procedures
  • Client delivery: project processes, quality standards
  • Sales: pipeline management, proposal templates, pricing guidelines
  • HR: hiring, onboarding, performance management
By system
  • Technical documentation for each tool and platform
  • Integration guides for how systems connect
  • Troubleshooting for common issues
  • Configuration and setup records
  • Admin guides for system administrators
By client
  • Client-specific knowledge linked to CRM records
  • Preferences, history, things to remember
  • Past project summaries and lessons learned
  • Key contacts and relationship dynamics
  • Billing arrangements and contract specifics
By project
  • Decision records for major choices
  • Technical architecture documentation
  • Implementation notes for future reference
  • Retrospectives and lessons learned
  • Handover documentation for maintenance

Clear categories and consistent naming. Cross-linking between related documents. A structure that matches how people actually look for information, not how someone imagined they should look. Modern documentation platforms like Notion or Confluence offer templates and structures designed for this kind of organisation.

The structure should allow for multiple entry points. Someone might search for "client X" and find client-specific notes. They might search for "invoicing" and find the finance procedures. They might search for "that integration we built in 2023" and find the project documentation. Different paths to the same knowledge.


Process Documentation Best Practices

A process document should enable someone to complete a task correctly without asking for help. The test is simple: give it to someone new and watch them work. If they have to ask questions, the documentation needs improvement.

Purpose and scope
  • What this process accomplishes (the outcome)
  • When to use it (and when not to)
  • Who typically performs it
  • Prerequisites: what needs to be true before starting
  • Time estimate: how long it typically takes
Step-by-step instructions
  • Numbered steps in order
  • One action per step (don't bundle)
  • Screenshots where the interface isn't obvious
  • Links to tools, templates, and related documents
  • Expected outcomes at checkpoints
Variations and decision points
  • Common variations: "If X, do this instead"
  • Decision trees for complex branching
  • Edge cases that require different handling
  • When to deviate from the standard process
Troubleshooting
  • Common problems and their solutions
  • Error messages and what they mean
  • What to do when things go wrong
  • Who to escalate to and when
  • Recovery procedures if something breaks

Writing Guidelines for Process Documentation

Good process documentation follows a few key principles that make it usable under pressure:

Principle Poor Example Better Example
Be specific "Update the system" "In Salesforce, click Accounts > [Client Name] > Edit, then update the Status field to Active"
One action per step "Log in and navigate to the reports section and run the monthly report" "1. Log in to the system. 2. Click Reports in the left menu. 3. Select Monthly Summary."
Explain the why "Wait 24 hours before proceeding" "Wait 24 hours for the payment to clear before proceeding"
Include verification "Send the email" "Send the email. You should see a confirmation message. If not, check the Outbox."

Screenshots age quickly when interfaces change. Use them where they genuinely clarify something confusing, but don't rely on them for every step. Written instructions survive interface updates better than screenshots do.


Decision Records

Processes tell you how to do things. Decision records tell you why things are the way they are. Without decision records, you inherit decisions without understanding them. When circumstances change, you can't evaluate whether the original reasoning still applies.

When significant decisions are made, the system captures:

The decision itself

What was decided, when it was made, who made it or was involved. Clear statement of the choice that was made.

The context

What problem or opportunity prompted the decision. What constraints applied. What information was available at the time. What pressures influenced the choice.

The alternatives

What other options were considered. Why they were rejected. What trade-offs were involved. This prevents revisiting the same alternatives repeatedly.

The rationale

Why this option was chosen. What benefits were expected. What risks were accepted. What assumptions were made that could prove wrong.

Six months later, someone asks "why do we do it this way?" The answer is documented, not lost. When circumstances change, you can revisit decisions with full context. You might decide differently, or you might confirm the original choice was right. Either way, you're not guessing.

Decision records are particularly valuable for:

For technical teams, the Architecture Decision Records (ADR) format provides a lightweight template specifically designed for capturing technical decisions that future developers will thank you for.

  • Architecture choices: Why this platform, this vendor, this approach
  • Policy decisions: Why this rule exists, what problem it solves
  • Process design: Why the workflow works this way, what alternatives failed
  • Pricing and terms: Why this structure, what market factors influenced it

Search and Discoverability

Documentation that can't be found doesn't exist for practical purposes. If finding information takes longer than asking a colleague, people will ask colleagues. The knowledge base becomes a ghost town that nobody visits.

Search That Actually Works

Finding information should be faster than asking a colleague. This is the benchmark. If your knowledge base fails this test, people won't use it.

Full-text search
  • Search across all documentation, not just titles
  • Results ranked by relevance
  • Highlighted matches shown in context
  • Typo tolerance and synonym matching
Filtered search
  • By category (process, decision, technical)
  • By team or function
  • By date (recent vs historical)
  • By status (current vs archived)
Related content
  • "Also relevant" suggestions on each page
  • Cross-links between connected documents
  • Recently viewed by people with similar roles
  • Frequently accessed alongside this document
Search analytics
  • What people search for (demand signal)
  • What searches return no results (gaps to fill)
  • What documents are accessed most (high-value content)
  • What searches lead to immediate exits (poor matches)

Beyond Search: Contextual Surfacing

The best knowledge system doesn't wait for people to search. It brings relevant knowledge to them at the moment they need it.

In project tools
  • Opening a project type shows the relevant process guide
  • Standard templates attached to project creation
  • Quality checklists appear at review stages
  • Relevant past projects suggested as references
In client records
  • Client-specific notes visible when viewing the record
  • Past project summaries accessible from client page
  • Relationship history and preferences surfaced
  • Relevant procedures based on client type
In task management
  • How-to guides linked from task types
  • Checklists embedded in recurring tasks
  • Reference materials attached to work items
  • Troubleshooting guides when tasks are blocked
In communication
  • Relevant documentation suggested when discussing topics
  • Links to guides included in automated messages
  • Knowledge base searchable from chat tools
  • Bot suggestions based on conversation context

People don't have to remember to check the knowledge base. The system brings relevant knowledge to them at the moment they need it. This is the difference between documentation that's used and documentation that's forgotten.


Versioning and Keeping Documentation Current

Stale documentation is worse than no documentation because people trust it. They follow outdated procedures and make mistakes. They reference old policies that no longer apply. They waste time on processes that were replaced months ago. The system prevents staleness through version control and active ownership.

Version Control for Documentation

Every document should have a clear version history:

  • Change tracking Who changed what, when, with brief notes on why
  • Version comparison Ability to see what changed between versions
  • Rollback capability Restore previous versions if changes were incorrect
  • Major version flags Significant changes highlighted for notification
  • Effective dates When changes take effect (for policies and procedures)

Ownership and Review Schedules

Every document has an owner. One person is responsible for accuracy. This doesn't mean they write everything. It means they're accountable for ensuring the content stays correct and current.

An owner

  • One person responsible for accuracy
  • Notified when flagged as outdated
  • Accountable for periodic review
  • Can delegate updates but not accountability

A review schedule

  • Quarterly for stable processes
  • Monthly for frequently changing areas
  • Triggered when related systems change
  • Automated reminders that escalate if ignored

Review Cadences by Document Type

Different document types need different review frequencies:

Document Type Review Frequency Trigger Events
Core policies Annually Regulatory changes, leadership changes
Standard processes Quarterly Tool changes, error reports, onboarding feedback
Technical documentation Monthly or on deployment System updates, incident reports
Client-specific notes After each major engagement Contract renewal, relationship changes
Troubleshooting guides When incidents occur New issues discovered, procedure changes

The review is lightweight: confirm still accurate, update if not, mark reviewed. Five minutes for most documents. The system tracks completion and escalates overdue reviews. If an owner consistently misses reviews, either the content isn't important enough to maintain (archive it) or the owner assignment needs to change.


Knowledge Capture from Departing Employees

When someone gives notice, the clock starts. You have two to four weeks to capture what they know before it walks out the door. Most organisations waste this time on administrative tasks and handover meetings that barely scratch the surface. A systematic approach captures far more.

The Knowledge Exit Process

1

Day 1-2: Knowledge audit

Within 48 hours of notice, conduct a knowledge audit with the departing employee. Map what they know that isn't documented: processes they own, decisions they made, relationships they manage, systems they understand, problems they've solved. Create a list prioritised by business impact.

2

Week 1: Documentation sprint

The departing employee spends dedicated time documenting the highest-priority knowledge gaps. This isn't normal work time. Block their calendar. Give them a quiet space. Provide templates and structure. Review their output daily and ask clarifying questions.

3

Week 2: Recorded walkthroughs

For complex processes or tacit knowledge that's hard to write down, record video walkthroughs. Have them narrate their screen while completing tasks. Record Q&A sessions where colleagues ask about edge cases. These recordings become training materials.

4

Week 3-4: Shadow and validate

Whoever is taking over should shadow the departing employee and attempt tasks using only the documentation. Gaps and unclear areas surface quickly. Update the documentation in real time while the expert is still available to clarify.

What to Capture

Focus on knowledge that's hard to recreate:

Relationship knowledge
  • Key contacts and how they prefer to communicate
  • Political dynamics (who influences decisions)
  • History with difficult clients or situations
  • Informal agreements and understandings
Institutional memory
  • Why things are the way they are
  • Past attempts that failed (and why)
  • Unwritten rules and norms
  • Where bodies are buried (legacy issues to avoid)
Tacit expertise
  • Judgment calls: how they decide when rules don't cover it
  • Pattern recognition: signs that predict problems
  • Workarounds: unofficial solutions to known issues
  • Quality standards: what "good" looks like
Network and resources
  • External contacts who help (vendors, advisers)
  • Where to find obscure information
  • Tools and shortcuts they've developed
  • Community resources they rely on

The goal isn't to extract everything they know. It's to capture enough that the organisation can function and learn without them. Some knowledge loss is inevitable. The question is whether you lose 20% or 80%. Your team handover processes should incorporate knowledge capture as a standard step, not an afterthought.


Knowledge Management and Training

Knowledge management and training are two sides of the same coin. The knowledge base provides the content. Training provides the structure for learning it. Neither works well without the other.

Documentation as Training Material

Well-structured documentation becomes the foundation for training programmes:

  • Onboarding paths Curated sequences of documentation that new starters work through in order
  • Role-based curricula Different documentation sets for different roles: what a salesperson needs vs what an accountant needs
  • Skill development tracks Progressive documentation from basic to advanced for building expertise
  • Self-paced learning People can learn at their own speed, returning to reference material as needed

Training that Creates Documentation

Training sessions are knowledge capture opportunities:

Record everything

Training sessions become video references. Q&A sessions reveal gaps and edge cases. Demonstrations show how experts actually work. These recordings supplement written documentation.

Feedback loop

Questions from trainees reveal documentation gaps. If the same question comes up repeatedly, the documentation needs improvement. Training becomes a quality check on the knowledge base.

Onboarding Integration

New starters should experience the knowledge base as their primary learning resource, not as a supplement to shadowing:

Week Traditional Onboarding Knowledge-First Onboarding
Week 1 Shadow colleagues, absorb what comes up Work through onboarding documentation, complete exercises, ask questions
Week 2 Start doing tasks, interrupt colleagues when stuck Attempt tasks using documentation, flag gaps discovered
Week 3-4 Learn through trial and error Work independently, reference documentation, contribute improvements

The result: faster time to productivity, less burden on existing staff, and documentation that improves with each new starter. A well-designed hiring and onboarding system integrates knowledge management from day one, ensuring new starters both consume and contribute to your institutional knowledge.


Creating Knowledge as a Byproduct

Documentation shouldn't be a separate activity. If capturing knowledge requires stepping away from normal work, it won't happen consistently. Knowledge should be captured as work happens.

From project work
  • Project kickoff creates a project knowledge record
  • Key decisions logged as they're made
  • Lessons learned captured at project close
  • Technical documentation created during implementation
  • Templates saved from successful deliverables
From support and troubleshooting
  • Support tickets that reveal knowledge gaps flagged
  • Solutions to novel problems captured as they're found
  • FAQ entries created from repeated questions
  • Troubleshooting guides built from incident resolutions
  • Workarounds documented until proper fixes deployed
From meetings and discussions
  • Meeting notes linked to relevant records
  • Decisions from meetings captured in decision log
  • Action items that reveal process gaps flagged
  • Discussion outcomes documented where relevant
  • Commitments recorded for future reference
From onboarding
  • Questions from new starters reveal documentation gaps
  • Training sessions recorded for future reference
  • First-week observations captured as fresh perspective
  • "I wish I'd known" feedback collected at 30/60/90 days
  • Confusion points flagged for clarity improvements

The goal: documentation is a natural output of work, not a separate project that never quite happens. Workflows should prompt for knowledge capture at natural moments. The friction of documentation should be low enough that it happens.


Measuring Knowledge Accessibility

You can't improve what you don't measure. Knowledge management has measurable outcomes that indicate whether the system is working.

Usage Metrics

Track whether people are actually using the knowledge base:

Search activity
  • Searches per day/week
  • Unique users searching
  • Search terms (what are people looking for)
  • Failed searches (no results)
Document engagement
  • Page views by document
  • Time on page
  • Bounce rate (left immediately)
  • Return visits
Contribution activity
  • New documents created
  • Updates to existing documents
  • Contributors (how many people)
  • Reviews completed on time

Quality Metrics

Track whether the content is actually helpful:

  • Feedback ratings Did this help? Thumbs up/down on each document
  • Outdated flags How often content is flagged as incorrect or stale
  • Review compliance Percentage of documents reviewed on schedule
  • Coverage assessment Percentage of critical processes documented

Outcome Metrics

Track whether the system is achieving its goals:

Metric What It Measures Target Direction
Time to find information How long it takes to answer common questions Decreasing
Questions to colleagues Interruption rate for "how do I" questions Decreasing
Onboarding time Time until new starters are productive Decreasing
Error rate on documented processes Mistakes made following procedures Decreasing
Knowledge retention at departures Disruption when people leave Decreasing

Use data to improve. If certain documents are never viewed, question whether they're needed. If searches fail, create the missing content. If reviews lapse, simplify the process or reassign ownership.


Getting Started

Building a knowledge base from scratch is daunting. The key is to start small and build momentum through consistent small contributions rather than heroic documentation projects that burn people out.

1

Audit and prioritise

List the "Ask Sarah" questions: what do people always ask about? Identify the critical processes: what would hurt most if done wrong? Find existing scattered documentation. Prioritise: what 10 documents would save the most time?

2

Foundation (Month 1)

Create the structure (categories, naming conventions). Document the top 5 most-asked processes. Assign ownership for each document. Set up the review schedule. Get the search working well enough that people find things.

3

Expansion (Month 2-3)

Document remaining priority processes. Start capturing decisions as they happen. Build client-specific knowledge into client records. Train team on contributing. Establish the habit of documentation as part of work.

4

Ongoing maintenance

Weekly: address flagged issues. Monthly: review due documents. Quarterly: assess coverage gaps and search analytics. Annually: major structure review. The knowledge base grows through consistent small contributions.

Start small: Don't try to document everything at once. Pick the three processes that cause the most repeated questions. Document those well. Then expand. Momentum matters more than completeness at the start.


How It Connects

Knowledge management connects to everything else in your operations. It's the foundation that other systems build on.

  • To onboarding New starters get guided learning paths through relevant documentation, reaching productivity faster
  • To projects Project types link to their standard processes, templates, and lessons from similar past work
  • To client records Client-specific knowledge lives alongside client data, visible when people need it
  • To handovers Documented knowledge makes transitions smoother when work moves between people or teams
  • From incidents Problems surface knowledge gaps that get addressed, turning mistakes into learning
  • From feedback User questions reveal what needs documenting, keeping the knowledge base aligned with real needs

The knowledge base isn't a separate system sitting to the side. It's woven into how work happens, surfacing where people need it and growing through normal operations.


The Difference It Makes

With a proper knowledge management system, the organisation changes in measurable ways:

  • Questions get answered People find what they need without interrupting colleagues. Self-service becomes the norm.
  • Onboarding accelerates New starters learn from documentation, not just shadowing. Time to productivity drops by weeks.
  • Handoffs work Departures don't take institutional knowledge with them. Transitions become manageable events, not crises.
  • Consistency improves Everyone works from the same documented processes. Quality becomes predictable.
  • Context survives Decisions and history are preserved, not forgotten. The organisation remembers why things are the way they are.
  • Experts are freed The "Ask Sarah" bottleneck disappears. Specialists focus on hard problems, not repeated explanations.

The organisation becomes less dependent on specific individuals. Knowledge is shared infrastructure, not personal property. The collective intelligence of the organisation accumulates over time instead of resetting with each departure.


Build Your Knowledge System

We build knowledge management systems that match how your organisation actually works. Your categories, your process types, your review cycles. The system captures knowledge as a byproduct of work and surfaces it where people need it. Not a generic wiki you'll abandon. Software that makes documentation sustainable and useful.

Let's talk about your knowledge management →
Graphic Swish