Journey Maps

The task inventory showed each task as a separate row, yet the user performs them back to back. The “find the shelf location” task starts on screen, ends in front of the shelf, and when it fails, the user goes back to the catalog. The inventory cannot see this chain; it counts each task as an independent event.

A journey map is the end-to-end tracking of a single goal: where the user starts, which stages they pass through, how long they stay at each stage, and where they give up. This lesson builds the map’s columns, calculates the drop-off points, and shows why the longest stage is not the worst stage.

The Map’s Columns

A journey map assigns a column to four questions.

• Stage. A step the user takes toward their goal. A stage boundary sits where the user makes a decision or the environment changes; it does not map one-to-one onto interface screens.
• Channel. The medium the stage passes through. The catalog interface has three channels: screen, the library’s physical space, and the borrowing desk. A map with no channel column assumes a journey that starts and ends on screen.
• Measurement. How many people entered the stage, how many advanced to the next stage, and how much time passed at the stage. This column comes from observation data.
• Finding. What happened at the stage and why. This column comes from the interview; it is not a number but a coded phenomenon.

Keeping the last two columns separate matters. Measurement says where something was lost, the finding says why it was lost, and one does not substitute for the other.

Measuring the Journey

The calculation below tracks the “find a known record and borrow it” goal from a hundred starts. For each stage, the number entered and advanced, along with the average time spent at the stage, was logged.

// journey.mjs — end-to-end journey: stage-by-stage duration, drop-off, and wasted time

// The "find a known record and borrow it" journey tracked from 100 starts
// (data constructed for this lesson). channel: the medium the stage passes through.
const STAGES = [
  { name: "open the catalog",        channel: "screen",   entered: 100, advanced: 97, duration: 0.4 },
  { name: "type the search",         channel: "screen",   entered: 97,  advanced: 92, duration: 1.1 },
  { name: "scan the result list",    channel: "screen",   entered: 92,  advanced: 74, duration: 2.3 },
  { name: "read the record detail",  channel: "screen",   entered: 74,  advanced: 68, duration: 1.6 },
  { name: "note the shelf code",     channel: "screen",   entered: 68,  advanced: 61, duration: 0.5 },
  { name: "walk to the shelf",       channel: "physical", entered: 61,  advanced: 58, duration: 6.2 },
  { name: "find the book on the shelf", channel: "physical", entered: 58, advanced: 39, duration: 4.8 },
  { name: "complete the borrowing transaction", channel: "desk", entered: 39, advanced: 37, duration: 2.1 },
];

console.log("stage                                channel   entered  advanced  dropped  drop rate  duration  cumulative");
let totalDuration = 0;
for (const s of STAGES) {
  s.dropped = s.entered - s.advanced;
  s.dropRate = s.dropped / s.entered;
  totalDuration += s.duration;
  console.log(
    `${s.name.padEnd(37)} ${s.channel.padEnd(9)} ${String(s.entered).padStart(6)} ${String(s.advanced).padStart(8)} ` +
      `${String(s.dropped).padStart(8)} ${(s.dropRate * 100).toFixed(1).padStart(9)}% ${s.duration.toFixed(1).padStart(6)} ${totalDuration.toFixed(1).padStart(10)}`
  );
}
console.log(`\nend-to-end completion: ${STAGES.at(-1).advanced} / ${STAGES[0].entered}  (${STAGES.at(-1).advanced}%)`);
console.log(`end-to-end duration (for completers): ${totalDuration.toFixed(1)} min`);

// Channel share: how much of the journey happened on screen
const channelDuration = {};
for (const s of STAGES) channelDuration[s.channel] = (channelDuration[s.channel] ?? 0) + s.duration;
console.log("\nchannel   duration   journey share");
for (const [c, d] of Object.entries(channelDuration)) {
  console.log(`${c.padEnd(9)} ${d.toFixed(1).padStart(5)} min  ${((d / totalDuration) * 100).toFixed(1)}%`);
}

// Three separate definitions of "worst stage" do not point to the same stage
const maxBy = (key) => [...STAGES].sort((a, b) => b[key] - a[key])[0];
for (const s of STAGES) s.wastedPersonMinutes = s.dropped * s.duration;
console.log("\nmetric                       worst stage                          value");
console.log(`${"longest stage".padEnd(28)} ${maxBy("duration").name.padEnd(35)} ${maxBy("duration").duration.toFixed(1)} min`);
console.log(`${"most dropped".padEnd(28)} ${maxBy("dropped").name.padEnd(35)} ${maxBy("dropped").dropped} people`);
console.log(`${"highest drop rate".padEnd(28)} ${maxBy("dropRate").name.padEnd(35)} ${(maxBy("dropRate").dropRate * 100).toFixed(1)}%`);
console.log(`${"most wasted person-minutes".padEnd(28)} ${maxBy("wastedPersonMinutes").name.padEnd(35)} ${maxBy("wastedPersonMinutes").wastedPersonMinutes.toFixed(1)} person-minutes`);

// Time spent by those who dropped: total minutes for those who entered but never exited the journey
let spent = 0, completerMinutes = STAGES.at(-1).advanced * totalDuration;
for (let i = 0; i < STAGES.length; i++) {
  spent += STAGES[i].entered * STAGES[i].duration;
}
console.log(`\ntotal time spent: ${spent.toFixed(1)} person-minutes`);
console.log(`completers' time: ${completerMinutes.toFixed(1)} person-minutes`);
console.log(`share of time with no result: ${(((spent - completerMinutes) / spent) * 100).toFixed(1)}%`);

stage                                channel   entered  advanced  dropped  drop rate  duration  cumulative
open the catalog                      screen       100       97        3       3.0%    0.4        0.4
type the search                       screen        97       92        5       5.2%    1.1        1.5
scan the result list                  screen        92       74       18      19.6%    2.3        3.8
read the record detail                screen        74       68        6       8.1%    1.6        5.4
note the shelf code                   screen        68       61        7      10.3%    0.5        5.9
walk to the shelf                     physical      61       58        3       4.9%    6.2       12.1
find the book on the shelf            physical      58       39       19      32.8%    4.8       16.9
complete the borrowing transaction    desk          39       37        2       5.1%    2.1       19.0

end-to-end completion: 37 / 100  (37%)
end-to-end duration (for completers): 19.0 min

channel   duration   journey share
screen      5.9 min  31.1%
physical   11.0 min  57.9%
desk        2.1 min  11.1%

metric                       worst stage                          value
longest stage                walk to the shelf                   6.2 min
most dropped                 find the book on the shelf          19 people
highest drop rate            find the book on the shelf          32.8%
most wasted person-minutes   find the book on the shelf          91.2 person-minutes

total time spent: 1249.2 person-minutes
completers' time: 703.0 person-minutes
share of time with no result: 43.7%

What the Map Says

End-to-end completion is 37%. None of the eight stages has a drop-off rate higher than a third, but their product brings a hundred down to thirty-seven. Stages looking “acceptable” one by one does not mean the chain is acceptable. A journey map’s first function is to show the product of numbers that look good stage by stage.

The screen is only 31.1% of the journey. Of the nineteen-minute journey, eleven minutes pass in the physical space and two at the desk. This is a region the catalog interface’s measurement cannot see: screen measurement goes blind the moment the user closes the catalog. The previous lesson’s session duration of 4.3 minutes for the Known-Record Searcher persona is a result of this blindness; the user is on screen for four minutes and off screen for fifteen.

The longest stage is not the worst stage. “Walk to the shelf” is the longest stage at 6.2 minutes, but its drop-off rate is 4.9%. The user expects this duration and accepts it; it is an expected part of the journey. The “find the book on the shelf” stage takes 4.8 minutes and loses nineteen of the fifty-eight people who enter it. Length is not a sign of a problem; the problem is that the time spent produces no result.

Wasted person-minutes convert stages into a common unit. Multiplying the number of people who dropped off by the time spent at that stage gives the time wasted at that stage. “Find the book on the shelf” produces 91.2 person-minutes; of the total one thousand two hundred forty-nine person-minutes, 43.7% is time that reached no result. This ratio changes the design conversation: the problem is framed not as “37% completion is low” but as “forty-three points of the time spent bought nothing.”

An on-screen decision affects an off-screen stage. The largest loss being off screen does not mean the solution is off screen too. At the “note the shelf code” stage, seven of sixty-eight people drop off; some of the rest may also note the code incorrectly, and the cost of that is paid at the next stage. How the shelf code is shown in the record detail directly determines the 4.8 minutes spent at the shelf. The map makes this link visible; the task inventory does not.

Separating the Drop-Off Point from the Finding

What the table does not say is why nineteen people could not find the book at the shelf. The possible reasons call for very different solutions from each other: the book is checked out but the catalog is not current, the book was shelved in the wrong place, the shelf code was read but the shelving scheme was not understood, or the user stood in front of the right shelf and missed the book with their eyes.

Which of these applies is determined not by measurement but by a short interview conducted right after the stage. The shelf-code-unclear code, coded in the first lesson, appeared in seven of twelve participants; this finding supports the third possibility but does not prove it on its own. The map’s finding column records which stage a code belongs to — a code cannot be turned into a design decision until it is tied to a stage.

The Ethical Limit of Off-Screen Observation

A journey map requires observing the user in the physical space, and this creates obligations different from an on-screen recording.

Consent for shadowing is obtained separately. Consent given for catalog use does not cover being followed among the shelves. In shadowing, the participant knows the observer is present; covert surveillance is not a research method.

Third parties do not enter the record. In observation carried out in the physical space, other users who have not consented are also within view. When notes are taken, only the participant’s behavior is written down; the image, voice, or identifying detail of people nearby is not recorded.

Location data is reduced to a stage as soon as possible. A record in the form “third floor, shelf 4, at 11:20” identifies a person in time and place. The data that enters analysis is the stage name and duration; the raw location and time are deleted within the retention limit once aggregation is done.

Summary

• A journey map consists of stage, channel, measurement, and finding columns; measurement says where something was lost, the finding says why, and one does not substitute for the other.
• Drop-off rates that look acceptable stage by stage get multiplied; in the sample data, even though none of the eight stages exceeded a third, end-to-end completion stayed at 37%.
• Only 31.1% of the sample journey passes on screen; screen measurement goes blind once the user closes the interface, and session duration is not journey duration.
• The longest stage is not the worst stage; the wasted-person-minutes metric converts stages into a common unit, and in the sample data 43.7% of the time spent reached no result.
• Consent is obtained separately for observation in the physical space, third parties do not enter the record, and raw location-time data is deleted once it is reduced to a stage.

Next Step

The map shows where our own interface loses people, but it does not say whether these losses are unavoidable. Other systems solve the same task, and which decisions they made is measurable data: in how many steps do they complete it, which information do they show on which screen, and where do they diverge from each other in their decisions? The next lesson addresses how to read existing solutions: comparing step counts, telling conventions apart from deviations, and understanding why a decision turns out the same across everyone.