JAVA-290 · Lesson 1 of 12 · 33 min
Choosing the project and users
▶ Video coming soon A video version of this lesson is on the way.
On Monday, May 8, 2028, the last term of Hamza Belcourt's program began, and it had no lectures. The capstone course asks each team of three to build a real piece of software for a real client between May and August, deploy it where its users can reach it, hand it over with documentation and present it on the college's demo day. Every course in the program has led here: the console tools of the first term, the object-oriented ShopBook, the tests and builds, the database, the booking API and the pipeline Hamza finished with Leif Quarmby a few days earlier. This course is about using all of it at once, with other people, on a problem nobody has already solved in a textbook.
Hamza did not choose his teammates by chance. Noemi Petrosyan is in the second year of the college's JavaScript and Web Development program; she took the web security and accessibility course in the winter and spent the spring building pages for a dental clinic's website. Thierry Dumont sat beside Hamza in the database and testing courses and is the person in the class who reads error messages to the end. Both had heard about the booking API at Second Gear Cycles, and both wanted a client who would actually use what they built.
What makes a capstone different
In a course exercise, someone else has already decided what to build, how big it is and what counts as finished. In a capstone, the team makes those decisions, and making them well is half the work. Ingrid Vallancourt, who agreed to be the team's mentor as she had been Hamza's for two years, put it plainly at their first meeting: the most common way for a capstone to fail is not bad code, but a project that was too vague, too large or wanted by nobody.
| Course exercise | Capstone project |
|---|---|
| The problem is given | The team finds and frames the problem with a client |
| Requirements are complete and fixed | Requirements are discovered, change and must be prioritized |
| One person, one evening | Three people, sixteen weeks, other commitments |
| Finished when the tests pass | Finished when real users can use it and someone else can run it |
| Graded on the code | Judged on the result, the process, the documents and the demo |
The college sets a few rules. The project must have a client outside the team who will meet them at least every two weeks. It must be built with the technologies of the program, which for Hamza and Thierry means Java 21 or later, Spring Boot, PostgreSQL and the build and test tools of the second year. It must run somewhere other than a laptop by the end of the term. And each team member must be able to show, from the repository's history, what they contributed.
The team's calendar was short. The term runs from Monday, May 8 to Friday, August 25, and the demo day is Wednesday, August 23. All three have other commitments: Thierry works days at a distribution warehouse, Noemi has a part-time job at the dental clinic, and Hamza still volunteers at the shop on Saturdays. They agreed to meet with Ingrid on Wednesday evenings in the shop's back room, her usual night, and to keep everything else in the repository and a shared chat channel.
The team
| Member | Program | Strengths | Hours per week |
|---|---|---|---|
| Hamza Belcourt | Software development | Knows the shop, the booking API and the pipeline | 14 |
| Noemi Petrosyan | JavaScript and web development | HTML, CSS, accessibility, user testing | 12 |
| Thierry Dumont | Software development | SQL, tests, careful reviews | 10 |
The hours column was Ingrid's idea, and it was uncomfortable to fill in honestly. Teams overestimate their time because they count the hours they hope to have rather than the hours left after jobs, family and other courses. She asked each of them to name a number they would still believe on a bad week, and those are the numbers in the table.
Three candidate projects
Hamza had asked Odile Branscombe, the shop's general manager, what Second Gear needed most. On Wednesday, May 10, Odile came to the first team meeting with Tamsin Rhee, the lead volunteer mechanic, and Kofi Amankwah, the parts and stock lead, and each of them brought a candidate. The team had agreed beforehand to treat the meeting as discovery: listen, ask for evidence, and decide later.
| Candidate | Proposed by | The problem | Main users |
|---|---|---|---|
| A. Booking website | Odile | Customers can book repairs only by phone or in person; the phone rings all day and calls are missed while staff serve the counter | Customers, counter staff, mechanics |
| B. Fleet maintenance tracker | Tamsin | Service history of the rental fleet and the earn-a-bike bikes lives in a notebook; a cargo bike went out with worn brake pads in April | Mechanics |
| C. Donation intake tracker | Kofi | Donated bikes are logged on paper; nobody knows how many are waiting to be refurbished or how long they wait | Kofi, intake volunteers |
Candidate A was not new. The booking API that Hamza had built in the winter already answered requests for free repair slots and accepted bookings, and its review in April had promised a website for customers later in the year. Tamsin had offered in March to build the pages herself over the summer. At the kickoff she said what everyone suspected: with the summer repair season starting, she would not have the evenings, and she would rather be a client who tells the team what customers ask on repair nights.
Ingrid asked each client the same question: how do you know this is a problem, and how big is it? Tamsin had the notebook and the April brake pads. Kofi had a rough count of forty bikes waiting in the basement. Odile had something better: for two weeks in late April and early May, the counter staff had kept a tally sheet beside the phone, one line per call, with the hour, whether someone answered and what the caller wanted.
Thierry typed the tally sheet into a small program that evening. It is the first piece of evidence in the project's repository, and it is short enough to show whole.
import java.util.*;
public class Main {
// One line per call from the counter tally sheet: hour of day, answered (Y/N), purpose.
static final String[] LOG = {
"9 Y booking", "9 Y booking", "10 Y booking", "10 N ?", "10 Y hours", "11 N ?", "11 Y booking",
"11 Y parts", "11 N ?", "12 N ?", "12 Y booking", "12 N ?", "12 Y booking", "13 Y booking",
"13 N ?", "13 Y hours", "14 Y booking", "14 N ?", "14 Y booking", "15 Y parts", "15 Y booking",
"16 Y booking", "16 N ?", "17 Y hours", "9 Y booking", "10 Y booking", "10 Y parts", "11 Y booking",
"11 N ?", "12 Y booking", "12 N ?", "12 N ?", "13 Y booking", "13 Y booking", "14 N ?",
"14 Y booking", "15 Y hours", "15 Y booking", "16 Y booking", "17 N ?"};
public static void main(String[] args) {
Map<Integer, int[]> byHour = new TreeMap<>(); // hour -> {calls, missed}
Map<String, Integer> purposes = new TreeMap<>();
for (String line : LOG) {
String[] p = line.split(" ");
int[] c = byHour.computeIfAbsent(Integer.parseInt(p[0]), h -> new int[2]);
c[0]++;
if (p[1].equals("N")) c[1]++;
else purposes.merge(p[2], 1, Integer::sum);
}
int calls = LOG.length, missed = 0;
for (var e : byHour.entrySet()) {
missed += e.getValue()[1];
System.out.printf("%2d:00 %d calls, %d missed %s%n", e.getKey(), e.getValue()[0], e.getValue()[1],
"#".repeat(e.getValue()[0]));
}
int answered = calls - missed;
System.out.println(calls + " calls, " + missed + " missed (" + (100 * missed / calls) + " in 100)");
System.out.println("answered calls by purpose: " + purposes);
System.out.println("bookings among answered calls: " + purposes.get("booking") + " of " + answered);
}
} 9:00 3 calls, 0 missed ###
10:00 5 calls, 1 missed #####
11:00 6 calls, 3 missed ######
12:00 7 calls, 4 missed #######
13:00 5 calls, 1 missed #####
14:00 5 calls, 2 missed #####
15:00 4 calls, 0 missed ####
16:00 3 calls, 1 missed ###
17:00 2 calls, 1 missed ##
40 calls, 13 missed (32 in 100)
answered calls by purpose: {booking=20, hours=4, parts=3}
bookings among answered calls: 20 of 27What this code does
Each tally line is split into its hour, whether the call was answered and its purpose, which is a question mark for missed calls because nobody knows what the caller wanted. A TreeMap keeps the hours in order, and the int array holds two counters per hour so a single pass fills both. The result shows that most answered calls are bookings and that the missed calls bunch around midday, when the counter is busiest.
The numbers changed the conversation. Out of forty calls in the sample, thirteen were missed, and most of the answered calls were bookings that a website could take without anyone picking up the phone. The midday bunching mattered too: those are the hours when Kofi and the counter volunteers are serving customers in person and cannot also take a booking. Odile added that the sheet covered only the calls people remembered to write down.
Criteria before choices
Choosing between candidates by enthusiasm favors whoever speaks most confidently. Ingrid suggested the team agree on criteria first, give each a weight, and only then score the candidates, so that the argument is about the criteria rather than about each other's favorite. This is a weighted decision matrix, an old tool from engineering and operations research, and its value lies less in the final number than in the discussion it forces.
| Criterion | Question | Weight |
|---|---|---|
| Value to the shop | How much time, money or trouble does it save, on the evidence? | 5 |
| Users reached | How many people will use it each week? | 3 |
| Feasible in the term | Can three people with our hours finish a useful version by August? | 4 |
| Learning fit | Does it use the whole program: data, services, pages, tests, deployment? | 3 |
| Client availability | Will the client meet us every two weeks and answer questions? | 2 |
| Risk | How likely are outside dependencies to stop us? (higher score means lower risk) | 3 |
Each team member scored each candidate from 1 to 5 on each criterion, alone and on paper, before anyone said a number aloud, so that the first opinion spoken did not anchor the others. The program below holds the agreed scores, the averages after a short discussion of any criterion where the three differed by more than one point.
import java.util.*;
public class Main {
record Criterion(String name, int weight) {}
public static void main(String[] args) {
List<Criterion> criteria = List.of(
new Criterion("value", 5), new Criterion("users", 3), new Criterion("feasible", 4),
new Criterion("learning", 3), new Criterion("client", 2), new Criterion("risk", 3));
Map<String, int[]> scores = new LinkedHashMap<>();
scores.put("A booking website", new int[] {5, 5, 3, 5, 4, 3});
scores.put("B fleet tracker", new int[] {3, 1, 5, 3, 3, 4});
scores.put("C donation intake", new int[] {3, 2, 4, 3, 2, 4});
int max = criteria.stream().mapToInt(Criterion::weight).sum() * 5;
String best = null;
int bestTotal = -1;
for (var e : scores.entrySet()) {
int total = 0;
for (int i = 0; i < criteria.size(); i++) total += criteria.get(i).weight() * e.getValue()[i];
System.out.printf("%-18s %3d of %d%n", e.getKey(), total, max);
if (total > bestTotal) { bestTotal = total; best = e.getKey(); }
}
System.out.println("highest: " + best);
}
}A booking website 84 of 100 B fleet tracker 65 of 100 C donation intake 62 of 100 highest: A booking website
What this code does
Each candidate's total is the sum of weight times score over the six criteria, and the maximum possible is five times the sum of the weights. A LinkedHashMap keeps the candidates in the order they were entered so the output is stable. The booking website wins clearly on value, users and learning fit, while the fleet tracker is the most feasible.
A total is only as good as its weights, and a team can make any candidate win by adjusting them after seeing the result. Thierry proposed a check: change each weight by one in each direction and see whether the winner changes. If a small change in a debatable weight flips the decision, the team should talk about that weight; if no small change does, the decision is robust.
import java.util.*;
public class Main {
static final String[] NAMES = {"value", "users", "feasible", "learning", "client", "risk"};
static final String[] CANDIDATES = {"A", "B", "C"};
static final int[][] SCORES = {{5, 5, 3, 5, 4, 3}, {3, 1, 5, 3, 3, 4}, {3, 2, 4, 3, 2, 4}};
static String winner(int[] w) {
int best = -1, at = -1;
for (int c = 0; c < SCORES.length; c++) {
int t = 0;
for (int i = 0; i < w.length; i++) t += w[i] * SCORES[c][i];
if (t > best) { best = t; at = c; }
}
return CANDIDATES[at];
}
public static void main(String[] args) {
int[] weights = {5, 3, 4, 3, 2, 3};
System.out.println("winner with agreed weights: " + winner(weights));
int flips = 0;
for (int i = 0; i < weights.length; i++) {
for (int d : new int[] {-1, 1}) {
int[] w = weights.clone();
w[i] = Math.max(1, Math.min(5, w[i] + d));
String win = winner(w);
if (!win.equals("A")) { flips++; System.out.println(" " + NAMES[i] + " " + w[i] + " -> " + win); }
}
}
System.out.println(flips == 0 ? "no single change of one flips the result" : flips + " change(s) flip it");
int[] extreme = {1, 1, 5, 1, 1, 5};
System.out.println("if only feasibility and risk mattered: " + winner(extreme));
}
}winner with agreed weights: A no single change of one flips the result if only feasibility and risk mattered: B
What this code does
The winner method recomputes every total for a given set of weights and returns the letter of the best candidate. The loop tries each weight one lower and one higher, clamped to the range 1 to 5, and reports any change that makes a different candidate win. None does, so the choice is robust, and the last line shows the weights a very cautious team would need before the fleet tracker won.
The last line of output was worth saying aloud. If the team cared about almost nothing except finishing safely, the fleet tracker would win, and that is a legitimate choice for some teams. But the evidence of the phone log, the number of users and the fact that the booking API already existed made the website the better bet, provided the team managed its scope. Tamsin agreed, on one condition: the fleet tracker should go in the shop's list of future projects, not in the bin. It did, as the first entry of a page in the repository's wiki called Later.
Deciding and writing it down
Before the meeting ended, Odile asked for one paragraph she could show the board. The team wrote a vision statement using the template Geoffrey Moore published in Crossing the Chasm in 1991, which forces a team to name the users, the need, the product's category, its key benefit and what it replaces.
# Vision: the Second Gear booking website
For customers of Second Gear Cycles who want their bike repaired,
who today can book only by phone or in person during opening hours,
the booking website is a public web page at book.secondgear.org
that lets them see free repair times and book, check or cancel a repair
at any hour from a phone or computer.
Unlike phoning the shop, it never puts them on hold, and it frees counter
staff to serve the people standing in front of them.What this code does
The template has five slots: for whom, who need what, the product is what kind of thing, that does what, and unlike what alternative. Filling every slot made the team name the alternative being replaced, phoning the shop, which later became the main success measure. The file lives at the top of the repository as VISION.md.
They also agreed on how they would know, at the end of the term and afterwards, whether it had worked. A goal that cannot be checked is only a hope, so each success measure had a number and a date. Odile insisted on the last one; a website that looked good on demo day but was never used would not help the shop.
| Measure | Today (estimate) | Target |
|---|---|---|
| Repair bookings made online | none | At least one in three bookings by the end of October 2028 |
| Missed calls in a two-week tally | 13 of 40 | Half as many as in the spring tally |
| Customers who do not arrive for a booking | unknown | Measured from the first week; reduced by reminders |
| Counter staff who can run the staff pages without help | none | Everyone on the counter rota by demo day |
Who the users are
A user is someone who will operate the software. A stakeholder is anyone affected by it or with a say in it, which includes users but also people like Odile, who will rarely open the website but decides what it must do, and the shop's board, which pays for the server. Confusing the two leads to software built for whoever attends the meetings. The team made a list of every group and marked which were users.
| Group | User? | What they need from the website |
|---|---|---|
| Customers booking a repair | Primary | Find a time quickly on a phone, book without an account, change their mind |
| Counter staff and volunteers | Primary | See the day's bookings, check customers in, fewer phone interruptions |
| Mechanics, led by Tamsin | Secondary | Know in the morning which bikes and problems are coming |
| Kofi, parts and stock | Secondary | Customers warned when a likely part is out of stock |
| Odile, general manager | Stakeholder | Weekly figures; confidence that customer data is handled properly |
| Leif, who runs the server | Stakeholder | Something that deploys through the existing pipeline and can be monitored |
| The board | Stakeholder | A sensible use of volunteer and server time |
Noemi pushed the team to go one step further for the primary users. In her web courses she had learned to describe users as personas: short, specific portraits of typical users based on evidence, used to test design choices. A persona is useful only if it is grounded in what real users said or did. One invented from imagination tends to become a portrait of the developer, and one built on stereotypes leads to designs that serve nobody. So the team agreed to draft personas now, from the phone log and the clients' experience, and to correct them after watching real customers in lesson 2.
| Persona | Situation | What matters to them |
|---|---|---|
| Dana, commuter | Rides to work every day; can only call at lunch, when the line is busiest | Booking in under two minutes on a phone; a reminder |
| Marcus, parent | Brings two children's bikes in spring; often needs to rebook | Several bookings, cancelling and rebooking easily |
| Rosa, retired | Uses a large text size and sometimes a screen reader; prefers to phone | Clear pages that work with her settings; the phone must stay an option |
| Jordan, earn-a-bike graduate | Seventeen, a phone with an old browser and limited data | Light pages that work without the latest browser |
Rosa's row changed a decision before any code existed. If some customers prefer to phone, the website must not replace the phone; it must reduce the calls so that the remaining ones get answered. And because the shop is in Ontario, where the accessibility of public services is a legal as well as a moral matter, the team wrote down accessibility as a requirement from the first day, not as polish for the last week.
With users identified, the team checked that the candidate actually served each primary user, and that every user group had at least one need the first version would meet. The check is simple, but it caught a gap: nothing on the first draft list served the mechanics.
import java.util.*;
public class Main {
public static void main(String[] args) {
Map<String, List<String>> needs = new LinkedHashMap<>();
needs.put("customer", List.of("see free times", "book", "cancel", "reminder"));
needs.put("counter", List.of("day list", "check in", "fewer calls"));
needs.put("mechanic", List.of("morning list of bikes and problems"));
needs.put("parts", List.of("out-of-stock warning"));
Set<String> firstDraft = Set.of("see free times", "book", "cancel", "reminder", "day list",
"check in", "fewer calls", "out-of-stock warning");
for (int round = 1; round <= 2; round++) {
System.out.println("round " + round + ":");
int unserved = 0;
for (var e : needs.entrySet()) {
List<String> missing = e.getValue().stream().filter(n -> !firstDraft.contains(n)).toList();
long met = e.getValue().size() - missing.size();
System.out.printf(" %-9s %d of %d needs met%s%n", e.getKey(), met, e.getValue().size(),
missing.isEmpty() ? "" : " missing " + missing);
if (met == 0) unserved++;
}
System.out.println(" user groups with nothing: " + unserved);
if (round == 1) {
needs.put("mechanic", List.of("day list")); // Tamsin: the day list with problems is enough
}
}
}
}round 1: customer 4 of 4 needs met counter 3 of 3 needs met mechanic 0 of 1 needs met missing [morning list of bikes and problems] parts 1 of 1 needs met user groups with nothing: 1 round 2: customer 4 of 4 needs met counter 3 of 3 needs met mechanic 1 of 1 needs met parts 1 of 1 needs met user groups with nothing: 0
What this code does
The map lists each user group's needs in a fixed order, and the set holds the features on the team's first draft. For each group the stream keeps the needs that no feature meets, and a group with nothing met is counted as unserved. In the second round the mechanics' need is restated, after Tamsin said that the counter's day list would serve her if it showed each bike's problem, and every group is covered.
Sizing the project to the team
The last question of the evening was whether three people could build the website in the time they had. Nobody could estimate the features yet, but they could count the time. Ingrid's rule of thumb from her own team at work was that only about two thirds of the hours a person sets aside for a project turn into finished work; the rest goes into meetings, reviews, setting up tools, helping each other and the unexpected. Thierry turned the rule into a program so they could change its inputs later.
import java.time.*;
import java.time.temporal.ChronoUnit;
import java.util.*;
public class Main {
public static void main(String[] args) {
LocalDate start = LocalDate.of(2028, 6, 1); // sprint 1 starts after four weeks of preparation
LocalDate codeFreeze = LocalDate.of(2028, 8, 9); // end of the last sprint
long weeks = ChronoUnit.WEEKS.between(start, codeFreeze.plusDays(1));
Map<String, Integer> hoursPerWeek = new LinkedHashMap<>();
hoursPerWeek.put("Hamza", 14);
hoursPerWeek.put("Noemi", 12);
hoursPerWeek.put("Thierry", 10);
Map<String, Integer> weeksAway = Map.of("Hamza", 0, "Noemi", 1, "Thierry", 1);
int total = 0;
for (var e : hoursPerWeek.entrySet()) {
int h = e.getValue() * (int) (weeks - weeksAway.get(e.getKey()));
total += h;
System.out.println(e.getKey() + ": " + h + " hours");
}
int focused = total * 2 / 3;
System.out.println(weeks + " weeks of building, " + total + " hours set aside");
System.out.println("about " + focused + " hours of finished work after meetings, reviews and surprises");
}
}Hamza: 140 hours Noemi: 108 hours Thierry: 90 hours 10 weeks of building, 338 hours set aside about 225 hours of finished work after meetings, reviews and surprises
What this code does
ChronoUnit.WEEKS counts whole weeks between the first day of sprint 1 and the day after the code freeze, which gives the ten weeks of building. Each person's weekly hours are multiplied by the weeks they will actually be there, after one week of holiday each for Noemi and Thierry. The two-thirds factor is a rough allowance for everything that is not building features, and the result gives the team a budget to plan against in lesson 4.
About 225 hours of finished work is not much: fewer than six weeks of one full-time developer. It was enough for a useful booking website only if the team kept the first version small and built on the API that already existed. That was the strongest argument for candidate A in the end. Most of the hard parts, the slot rules, the database and the pipeline, were already there and tested, so the team's hours could go into what customers would see.
On the way out, Kofi asked whether the team would also build an app. Hamza said no, and wrote down why: a website that works well on phones reaches every customer with a browser, needs no store approval and goes through the same pipeline as the API. The question went onto the Later page too, under the fleet tracker.
Exercises
Try it yourself
Re-weight the decision
The team's scores are in SCORES, one row per candidate, one column per criterion in the order value, users, feasible, learning, client, risk. Complete total so that it returns the weighted sum of a candidate's scores, then print each candidate's total for the weights {2, 2, 5, 2, 2, 5} in the form shown, followed by the winner.
public class Main {
static final String[] CANDIDATES = {"A", "B", "C"};
static final int[][] SCORES = {{5, 5, 3, 5, 4, 3}, {3, 1, 5, 3, 3, 4}, {3, 2, 4, 3, 2, 4}};
static int total(int[] scores, int[] weights) {
return 0;
}
public static void main(String[] args) {
int[] weights = {2, 2, 5, 2, 2, 5};
for (int c = 0; c < SCORES.length; c++) {
System.out.println(CANDIDATES[c] + ": " + total(SCORES[c], weights));
}
}
}Try it yourself
How many hours are left?
Each entry of team is name hoursPerWeek weeksAway. The building period has 10 weeks. Complete main so that it prints each person's hours (hours per week times the weeks they are present), the total, and the focused hours, which are two thirds of the total rounded down. Use integer arithmetic.
import java.util.*;
public class Main {
public static void main(String[] args) {
List<String> team = List.of("Hamza 14 0", "Noemi 12 2", "Thierry 10 1");
int weeks = 10;
System.out.println("total: 0");
}
}By the end of the evening the team had a project, a client who would meet them every two weeks, a list of users, a vision paragraph and a budget of hours. They had no requirements yet, only a direction. The next step, on the Saturday and the Tuesday that followed, was to watch real customers and write down what they needed in a form the team could build and test.
Common mistakes
MistakeChoosing the project the team finds most interesting.
InsteadChoose on agreed criteria and evidence, with the client, and check that the choice survives small changes to the weights.
MistakeAccepting a problem without evidence of its size.
InsteadAsk how the client knows it is a problem, and measure it if nobody has, as the phone tally did.
MistakeTreating everyone in the meeting as a user.
InsteadList users and stakeholders separately, and design for the people who will operate the software.
MistakeInventing personas from imagination or stereotypes.
InsteadBase personas on what real users said and did, and revise them after observing users.
MistakePlanning with the hours the team hopes to have.
InsteadPlan with honest weekly hours, minus absences, and allow for time that is not feature work.
MistakeThrowing away the candidates that lost.
InsteadRecord them with the reasons, so the client can come back to them.
Summary and key terms
- A capstone differs from course exercises because the team must find and frame the problem, prioritize changing requirements, work with a client and finish with software that others use and can run.
- The team gathered three candidates from the clients and asked for evidence of each problem, such as the phone tally that showed thirteen of forty calls missed around midday.
- They agreed weighted criteria before scoring, scored independently, and checked that changing any weight by one did not change the winner.
- The decision was recorded in a vision statement using Geoffrey Moore's template, with success measures that have numbers and dates.
- Users operate the software, while stakeholders are affected by it or have a say in it; personas describe typical primary users and must rest on evidence.
- A capacity estimate from honest weekly hours, absences and an allowance for non-feature work gave about 225 focused hours, which favored a small first version built on the existing booking API.
- Capstone
- A final project that brings together the skills of a whole program on a real problem.
- Client
- The person or organization the software is built for, who decides what it must do.
- Weighted decision matrix
- A table that scores options against criteria, each multiplied by an agreed weight.
- Sensitivity check
- Changing inputs such as weights slightly to see whether a decision still holds.
- Vision statement
- A short paragraph naming the users, their need, the product and what it replaces.
- Success measure
- A number with a target and a date that shows whether the project worked.
- User
- Someone who operates the software.
- Stakeholder
- Anyone affected by the software or with a say in what it must do.
- Persona
- A short, evidence-based portrait of a typical user, used to test design choices.
- Capacity
- The amount of work a team can finish in a period, after time that is not feature work.
Practice problems
Work each problem on paper first, then reveal the answer to check.
Why did the team score the candidates alone before discussing them?
Show answer
So that the first number spoken aloud did not anchor everyone else's scores.
What did the phone tally show besides the share of missed calls?
Show answer
That most answered calls were bookings and that missed calls bunched around midday, when the counter is busiest.
Why did Rosa's persona matter before any code was written?
Show answer
It showed that the phone must remain an option and that accessibility is a requirement from the start.
How did the team test whether its choice depended on debatable weights?
Show answer
It changed each weight by one in each direction and checked whether a different candidate won.
Why did the existing booking API make candidate A more feasible?
Show answer
The slot rules, database and pipeline already existed and were tested, so the team's limited hours could go into what customers see.
Lesson quiz · 5 questions
Score 60% or more to complete this lesson.
Create a free account to save your progress, take quizzes and earn a certificate.