← All articles

Knowledge Retention in Design: Keep the Why Behind Decisions

Knowledge Retention in Design: Keep the Why Behind Decisions

Knowledge retention in design means keeping the reasoning behind the work, not only the drawings, files and final decisions. The deliverables survive on their own. What disappears is why a option was chosen, what was rejected, and who agreed to what. The most reliable fix is to capture that reasoning from the conversations where it happens, link every decision back to its source, and keep it in one searchable project memory. That is what we built The Intent Ledger to do: it turns meeting notes, transcripts, critique feedback and client comments into ILM Records, structured records of decisions, design intent, risks, actions, commitments and unresolved questions.

Theintentledger
Keep the Why Behind Design Decisions
The Intent Ledger turns project conversations, critique feedback, and client comments into source-backed records that preserve design intent and context.
Visit

TL;DR

  • Design teams rarely lose files. They lose context: the intent, the alternatives considered and the assumptions behind a decision.
  • Research on design rationale shows that documentation tends to record outcomes and skip reasons, because writing everything up feels like it interrupts the work.
  • A usable record has a decision, an owner, the options considered, the rationale and a link to the conversation it came from. Capture it right after the discussion.
  • Actions, risks and unresolved questions need owners and a next check, or they quietly become lost commitments.
  • ILM Records give each of these a structured, source-backed home, so a junior designer, a new project manager or a client can trace any decision to its origin.

Table of Contents

What knowledge retention means on a design project

Outside design, “knowledge retention” usually means helping people remember what they studied. On a project it means something else: keeping what the team knows available after the people, the weeks and the meetings that produced it have moved on.

Researchers call this a project memory. A Design Research Society paper on global student design teams defines it as a collection of formal and informal information and knowledge that serves team members during the project and afterward as a project definition, a record of activities, a history and results. The authors argue it is more than an information warehouse. It is a place to share, reflect, make better-informed decisions and fold knowledge into new ideas.

Fruchter’s work on knowledge management for reuse makes the same point from the other direction. She describes “knowledge in context” as the design knowledge a designer holds in personal memory: detailed, contextual, and including how the design evolved, the rationale and the links between disciplines. Her practical motivation is plain. Capturing and reusing knowledge costs less than recreating it.

For a studio, that translates into a few everyday questions a good project memory should answer:

  • Why did we choose this façade system, layout or interaction pattern?
  • What did the client actually say, and when?
  • What did we reject, and why?
  • Who agreed to do what, and by when?
  • What is still undecided?

How knowledge loss happens in design projects

Knowledge loss is rarely dramatic. It is a slow leak, and the research describes where it happens.

Intent and rejected options go unrecorded

A NASA paper on design rationale capture states that design intent, the reasons a system was designed a certain way, and the options considered but rejected are rarely adequately captured. They sit in scattered documents, notebooks and people’s heads, so design knowledge often “goes with the employee.” The same paper notes that document repositories mostly store files in a line. They do not show what a changed requirement affects further down the design.

A capstone design study by Joshi and Summers found the same pattern at the conceptual stage. Design solutions that never made it into the final design were neither archived nor shared, and the rationale for design changes was not recorded in any form. That is useful information thrown away for anyone who later faces a similar problem.

Documentation records outcomes, not reasons

A paper on what it calls architectural knowledge vaporization explains why. Documentation tends to capture outcomes and miss decisions, context and rationale, because comprehensive documentation is seen as resource-intensive and as interrupting the design flow. The details that evaporate include the decision context, assumptions, decision drivers, consequences and the alternatives considered. The authors link this loss to design rules being violated as a system evolves.

The same paper sorts the lost knowledge into three kinds, which is a handy checklist for a studio:

Kind of knowledge What it covers Design example
Context Problem space, requirements, forces The client’s budget cap and the zoning constraint
Reasoning Rationale, alternatives, trade-offs Why a timber frame beat steel on cost and schedule
Design The models and components themselves The drawings and specifications

Most studios store the third row well. The first two are where the leak is.

Unwritten context lives in people

Designer Wouter de Bres describes the unwritten context behind decisions: the parts that never made it into the write-up and the memory of why something was tried and dropped. He ties this to the idea of transactive memory, where knowledge is spread across a group and each person knows who tends to know what. When someone leaves or rotates off a project, that knowledge does not move cleanly into documents. Teams then repeat old mistakes.

Remote and student teams feel this sharply. The Design Research Society study found that in a global student team, less than 10% of information in the shared file galleries was formal, mostly past reports, while images and video dominated. The authors also note that in virtual settings the benefits of tacit knowledge transfer are severely reduced, which makes context-rich information more valuable.

What a decision record needs to hold

Studies of real projects show that teams know what good documentation looks like and still fall short. Kinneging and colleagues studied four infrastructure projects and found that accessibility of decision documentation matched theory, but documentation of design decisions and their rationale was incomplete. The interrelations and context of decisions were barely documented, and neither immediate documentation nor periodic review was applied.

The same paper summarizes what the literature asks for. Document the decision itself, its rationale (the justification and the process), and the dependencies between decisions. Do it continuously, ideally right after the decision, and review earlier records at the start of each new project phase to establish a baseline.

In practice, a useful record answers these fields:

  1. The decision, written as one clear sentence.
  2. The owner, a named person rather than “the team.”
  3. The date and project stage.
  4. Options considered and the criteria used to compare them.
  5. The rationale and the trade-off accepted.
  6. The source: the meeting, transcript, critique or client email it came from.
  7. A review trigger, the condition that would reopen the decision.

We go deeper on the difference between a reason and an after-the-fact excuse in our piece on decision rationale versus justification, and our decision log template lays the fields out for a team that wants to start on paper.

A routine that keeps the why, step by step

The routine below works for a studio of three or a team of thirty. At each step we note where it usually breaks and what we do differently.

Step 1: Capture the conversation, not just the minutes

Decisions are made in review meetings, site calls, critiques and client emails. If you only keep the polished summary, the options and objections are gone. Keep the raw material: notes, a transcript, an audio recording, pasted client comments.

Where it goes wrong: the raw material piles up in folders nobody reads. This is the step we take off your hands. You bring the notes, transcripts, critique feedback or client comments, and The Intent Ledger turns them into ILM Records.

Step 2: Separate the discussion from the decision

A discussion note says what was talked about. A decision record says what was concluded and why. Mixing them produces long notes where the conclusion is hard to find. Keep the conversation as the source, and keep the decision as its own entry that points back to it.

Where it goes wrong: people paste the whole discussion into the decision field. An ILM Record is structured, so the decision, the design intent, and the supporting source each have their own place, and the record stays traceable to the conversation it came from. Our article on decision provenance explains why that trail matters.

Step 3: Record it while it is fresh

The literature favors recording immediately after the decision, and a lightweight record written within minutes of the discussion beats a polished one written next week. One person, such as the design lead or project manager, should own the capture so it does not fall between chairs.

Where it goes wrong: the person who was supposed to write it up was busy presenting. Working from the conversation itself means the record does not depend on someone’s recollection a week later.

Step 4: Give every action an owner and a next check

Project management guidance on RAID logs (risks, assumptions, issues and dependencies) says each item should carry a description, owner, priority, status, target date and a mitigation or action plan, and the log should be updated throughout the project. Two small rules keep it honest. If no owner or date was agreed, write “not agreed” rather than guessing. And read back the commitments before the meeting ends, so corrections happen while everyone is still in the room.

It also helps to keep four categories apart. A risk is something that might happen. An assumption is treated as true but unverified. An issue already exists, including an unresolved design problem. A dependency is waiting on another input or decision.

Where it goes wrong: “someone should check the fire strategy” is not an action. ILM Records hold actions, commitments, risks and unresolved questions as distinct items, so the open ones stay visible instead of sinking into last month’s notes.

Step 5: Review the record at each phase change

A memory nobody reads is an archive. Fruchter describes the cycle as knowledge being created, captured, stored, retrieved, reused and refined, so that the archive acts as a “knowledge refinery”. Build the retrieval step in: open the record at the start of each phase, at handoff, and when a new person joins.

Where it goes wrong: nobody remembers the record exists. Keeping decisions, risks and open questions in one living project memory means the review is a single place to look. Our guide to building project memory in 30 days walks through a rollout.

Making it work for your role

Studios and project managers

The real test of a project memory is the handoff. When a team member leaves, goes on leave or moves to another job, the next person should be able to see what was decided, why, and what is still open. A project manager who documents design conversations as they happen gives the studio continuity that does not depend on any one person’s memory.

Architecture knowledge systems go beyond a single project. One guide describes a firm-wide system with standards libraries, templates, documented workflows and a lessons-learned database fed by RFIs and construction experience. A project-level memory of decisions and rationale is what feeds that kind of database. If you want a practical model for recording what happens on site, this walkthrough of construction daily reports shows what to capture and how.

Junior designers

Juniors are often handed a task with no history. Why this material? Why did the client reject the first scheme? A source-backed record lets a junior trace the task to the conversation it came from, instead of guessing or interrupting a senior colleague. It also teaches how decisions get made.

Students and critiques

Critique feedback is easy to forget by the next studio session. A good design review structure moves critical feedback into an actions list with owners and deadlines, which leaves a permanent record of how the design and its reasoning evolved. For a student, that means writing down what the reviewer said, what you decided to change, and what you chose to ignore and why. Turning critique notes into ILM Records keeps that trail attached to the source, so you can show your reasoning in a final review or portfolio.

Freelance architects

For a freelancer the client relationship is the project memory. Approvals, changes of mind and verbal instructions pile up in email threads and phone calls. Keeping client comments as source-backed records means you can show what was asked, when, and what you did about it, without reconstructing it from your inbox.

Why a shared memory helps teams think

Project memory is not only a defense against loss. It helps a team reflect. When people can see how earlier decisions were reached, they build on them instead of relitigating them, and discussions move forward. That is the same logic behind scaffolded learning, where each step of progress rests on structure that earlier steps put in place. A project record gives a design team that scaffolding for its own decisions.

Where The Intent Ledger fits

The Intent Ledger is project memory software for design teams. It focuses on preserving the why behind the work, rather than the notes alone. Each ILM Record ties a decision, a piece of design intent, a risk, an action, a commitment or an unresolved question back to the conversation it came from.

You can start small with a one-time pack: Working Set is $12, Project Record is $29, Practice Memory is $59 and Studio Ledger is $119. Teams that create records continuously can choose a monthly plan: Working Memory at $29 per month, Living Record at $79 per month or Shared Ledger at $149 per month. Details are on the pricing page, and the Intent Ledger home page shows how ILM Records work.

Theintentledger

If you want to read more before choosing, our articles on decision-making documentation and design feedback sessions cover the practice in more depth.

Our perspective

We built The Intent Ledger on one observation: design teams already talk their way to good decisions, and then lose the reasons.

The decision survives in the drawing. The reason lives in a meeting that nobody can replay. Six months later, a new project manager, a junior designer or a client asks why, and the team reconstructs an answer from memory.

That is why an ILM Record keeps the source attached. A decision that points back to its conversation can be checked, explained and revisited. A decision stripped of its origin can only be defended.

We also think records should cover more than decisions. Risks, commitments and unresolved questions are part of the same story, and a project memory that holds all of them shows where a project actually stands. That is the kind of memory our packs and plans are designed to build, one project at a time.

Rajas

FAQ

What is knowledge retention in a design project?

It is keeping the knowledge a team builds while working, especially the context and reasoning, so it stays usable after people and phases change. Research describes this as a project memory that serves the team during the project and acts as a record of activities, history and results afterward.

What knowledge is most often lost?

The reasons, not the results. Studies find that design intent, the options considered and rejected, assumptions and decision drivers are rarely captured, while outcomes and drawings are well kept. Unwritten context, such as why an idea was tried and dropped, is lost when people leave.

How soon after a meeting should decisions be written down?

As soon as possible. The literature on design decision documentation recommends documenting continuously and preferably immediately after the decision is made, then reviewing earlier records at the start of each project phase. Recording while the discussion is fresh keeps the reasoning accurate.

What should a decision record include?

The decision, the owner, the date or stage, the options considered, the rationale, the trade-off accepted, and a link to the source conversation. Adding a review trigger tells the next person when the decision should be reopened.

How can a student or freelancer keep feedback useful later?

Write each piece of feedback as an entry with the source, your response and the reason for it, and keep actions with an owner and a date. Source-backed ILM Records do this from critique notes or client comments, so the reasoning remains traceable when you need it.

Sources