DEV Community: Rahul Devaskar

FIFA Top Thirds group logic

Rahul Devaskar — Sun, 28 Jun 2026 06:30:19 +0000

Rahul Devaskar

Jun 27

Eight kids, eight chairs, one rule: explaining FIFA's best-thirds draw to my 8-year-old

#webdev #soccer #math #worldcup

14 min read

Eight kids, eight chairs, one rule: explaining FIFA's best-thirds draw to my 8-year-old

Rahul Devaskar — Sat, 27 Jun 2026 18:20:26 +0000

The question

My son was on the sofa with his iPad, poking at the live "Predict the Bracket" game — the whole 2026 World Cup knockout tree on one screen, every slot already filled with the crowd's favourite for that match. Tap a match, see who most people think goes through, watch the picks flow all the way up to a predicted champion.

He frowned at it. "Daddy, how do they know which team plays which team? The teams aren't even decided yet."

He'd caught something real. The little cards sitting in those slots were only predictions — the crowd's best hunch — but the shape underneath them, who-plays-who and where, was already locked in. Months before a single match kicks off.

Fair question. The 2026 World Cup has 48 teams in 12 groups (A through L). The top two of every group go through — that's 24 teams. Then, to round it up to a nice bracket of 32, they also take the 8 best third-placed teams. Twelve groups, but only eight of their third-place teams get a golden ticket.

"So you don't know which eight until the very end," he said. "But the bracket's already sitting right there on the screen."

"Right."

"That's cheating."

It isn't cheating. It's one of the prettiest little bits of planning in all of sport, and by the end of the afternoon he understood it better than most adults do. We did it with the dining chairs.

The setup, first

Before the chairs, my son needed to know where these kids even come from. So we did the boring-but-important part first.

A football group is a handful of teams who all play each other. When it's done, the best go forward, the worst go home, and — this is the bit that matters — there's a kid right on the line: the best of the rest, neither safely through nor clearly out. That borderline kid is the star of this whole story. Call them a wandering kid.

To learn the trick, let's make the groups nice and small: two groups, A and B, three kids in each — six kids total. In each group the top kid goes straight through to the next round, the bottom kid is out, and the kid in the middle is our wandering kid. So two groups give us two winners through, two kids out, and two wandering kids — second place in Group A, second place in Group B.

(In the real World Cup the groups are bigger — four teams, with the top two safely through — so it's the third-place kids who do the wandering. Exact same puzzle, just more of everything. We'll scale up the moment the rule clicks.)

Two chairs

I lined up two chairs and labelled them with sticky notes: Chair A and Chair B.

"Here's the next round. The winner of Group A is waiting in Chair A's match, the winner of Group B in Chair B's. Our two wandering kids each grab a chair and become someone's opponent. Four kids in the round, two matches, two chairs — and it fits perfectly: every kid is either a waiting winner or a wandering kid, nothing left over."

That clean fit is the whole reason we kept the groups small. (Make them bigger and you also get runners-up, who pair off in their own matches — more bodies, but they never sit in a wandering kid's chair, so they don't change this puzzle one bit.)

Then the only rule:

You can't sit in the chair with your own group's name on it.

Why? Because a wandering kid and their own group's winner already played each other in the group stage. Making them replay immediately would be unfair. So the kid from Group A is banned from Chair A.

He worked it out instantly. Kid A can't sit in A, so kid A goes to B. Kid B goes to A. Done.

"There's only one way."

Two kids, two chairs — and exactly one fair way to seat them.

"Yep. Easy. Now watch it get sneaky."

The trap: a kid who isn't even from these groups

I kept the two chairs, A and B. But this time the two wandering kids were from team A and from team C (yes, there's a Group C in the mix now).

Notice: there's no Chair C. The kid from C has no banned chair — they can sit anywhere. I call them a free kid.

My son, being eight and therefore greedy, grabbed the free kid first and plonked them in Chair B.

"Done!"

"Is it though?"

Now the only kid left is from team A. The only chair left is Chair A. And kid A is banned from Chair A.

He stared at it. "...he's got nowhere to sit."

Seat the kids in the wrong order and someone can end up with nowhere to sit.

"You stranded him. The free kid could sit anywhere, so the free kid should have taken the chair nobody else could use — Chair A — and left Chair B for kid A."

This is the whole puzzle in miniature. There is always a way to seat everyone, but a careless grab can paint you into a corner. The order you make decisions matters. You have to think about the kid who has the fewest choices, not the one in front of you.

He re-seated them. Free kid in A, kid A in B. Everyone happy. He looked very pleased with himself.

"Okay," I said. "Now let's make it bigger — one step at a time."

Scaling up: three groups

The two-group game taught the rule. But the real tournament has a twist our tiny version skipped: it has to pick which wandering kids get a chair at all. So let's add exactly that — and nothing else yet.

Bump it up to three groups, four kids each — twelve kids. And now we'll do it the grown-up way: the top two from each group go straight through, just like the real World Cup. That's six safe qualifiers. The third-place kid from each group is left in limbo — three wandering kids.

But a knockout bracket likes tidy numbers: 2, 4, 8, 16. Six safe kids aren't a tidy number, and the next one up is eight. Six plus two makes eight — so there's only room for two wandering kids, and we've got three. Someone misses out.

That's the brand-new question, the one the two-group game never had to ask: which two of the three wandering kids get in? The two with the best records. And there are only three ways that can shake out — leave out the kid from A, or from B, or from C:

3 wandering kids, choose 2  →  3 possible line-ups

Pick the best two and it all lands clean: six safe + two chosen = eight kids, four matches. Two of the group winners get a wandering kid dropped in beside them (same rule — never your own group); the other four pair off among themselves.

Three ways. Hold onto that number — it's about to get a lot bigger.

Finally: the FIFA level

Now the real draw. Twelve groups, four kids each — forty-eight teams. Top two from every group march straight through: twenty-four safe qualifiers. The next tidy bracket size above twenty-four is thirty-two — so we need eight more kids, chosen from the twelve third-place teams. (Exact same move as the three-group game: 24 + 8 = 32, just like 6 + 2 = 8.)

In the real bracket, exactly eight of the twelve group winners are the ones waiting for a wandering third-place team: the winners of groups A, B, D, E, G, I, K, and L. The other four — C, F, H, J — get a runner-up instead.

My son pounced on that straight away: "Why are some groups treated differently?" Two reasons, and they're both fair.

It's a reward — and there aren't enough to go round. Winning your group is the prize, and part of the prize is an easier-looking opponent. A third-place team is the weakest kind of team that qualifies, so the bracket feeds those gentler match-ups to the group winners — a little thank-you for finishing first. (That's exactly why a wandering kid always plays a group winner, and never a runner-up.) But there are only eight wandering kids and twelve winners, so four winners are always going to miss the reward and draw a runner-up — a tougher opponent — instead.

Which four miss out? Whatever keeps the bracket balanced. FIFA sprinkles the eight wandering kids evenly across the bracket on purpose, so they don't all bunch into one corner and turn one route to the final into an easy stroll. Once those eight seats are pinned down for fairness, C, F, H and J are simply the winners left over — the ones whose spot in the tree happens to line them up against a runner-up. Nothing personal; just where the chairs landed.

"But that's not fair!"

He was instantly outraged on behalf of C, F, H and J. "Why should four winners get a tougher opponent? They won their group too!"

Good. Be cross about it. Here's why it's fairer than it looks.

Someone has to. Eight wandering kids, twelve winners — some four winners end up with a runner-up no matter how you arrange the bracket. It isn't a punishment aimed at anyone; it's just what's left over once the easy tickets run out.

It's decided with the lights off. When FIFA fixes which winners get a runner-up, the groups are still empty — nobody knows whether Group C will be won by a giant or by the tournament's surprise package. No real team is being picked on, because no real teams exist yet. By the time you find out who actually won Group C, the rule was already set in stone, blind. That's the fairest kind of unfair: agreed in advance, before anyone knows whom it lands on.

And winning still buys the big prize. The real reward for topping your group was never the third-placed team — it's that a group winner never has to play another group winner in this round. Even the four "unlucky" winners only face a runner-up: a team that finished second, below them. They're still the favourite — they just got the second-best easy draw instead of the very best one.

And honestly, "tougher on paper" isn't always tougher in real life. Think of Minecraft. A zombie sounds like a proper monster — but it's slow, it groans, and you watch it lumber toward you from a mile off. Easy. A creeper? Just a quiet green blob, minding its own business… right up until it blows your whole base sky-high. A runner-up can be the zombie: ranked higher, totally beatable. A third-placed team can be the creeper: looks harmless on the bracket, secretly ends your tournament.

My son chewed on that. "So it's only a little bit unfair." Exactly. A knockout bracket can never be perfectly equal — somebody's road to the final is always a touch bumpier than someone else's. The whole job is to keep that bump small, spread it around, and lock it in before anyone can argue about who it lands on.

Back to the chairs

Anyway — back to the puzzle. Eight chairs, labelled A, B, D, E, G, I, K, L. And eight kids — the eight best third-place teams. But here's the catch we knew was coming: you don't know which eight groups they'll come from. Maybe C, F, G, H, I, J, K, L. Maybe A, B, C, D, E, F, G, H. Any eight of the twelve.

Same single rule as the very first chairs game: no kid sits in the chair with their own group's letter. A third from Group K can never be sent to Chair K.

"That's just the chairs game but bigger," he said.

"Exactly. So how many different groups of eight could show up?"

Why 495

Back in the three-group game, "choose two of three" gave us three line-ups. The real draw asks the very same question, just bigger: choose eight of twelve. Still nothing but counting.

How many ways can you choose eight things out of twelve?

I explained "choosing" the way it clicks for a kid: choosing 8 to keep is exactly the same as choosing 4 to leave out. And picking which 4 groups miss out is easier to picture. It comes out to:

12 × 11 × 10 × 9
─────────────────  =  495
 4 × 3 × 2 × 1

(Mathematicians write this "12 choose 8" — but "how many ways to pick the 4 unlucky groups" is the same number, 495, and far easier to feel.)

He looked at the little sum, then up at me. "I don't get it."

And that's completely fine — I didn't either, at his age. "This one's got a big fancy name," I told him. "Permutations and combinations. I found it hard at school too, honestly. It doesn't really click until Year 10 or 11 — that's years and years away. You don't need it today."

"So how do I know it's right?"

"Take my word for it: the maths checks out. 495, exactly. And the formula isn't even the interesting bit — what FIFA does with that 495 is."

That was about the limit of his patience. He slid off the chair, said "okay, Daddy," and wandered off to build a Lego stadium on the rug — happy, I think, that the chart wasn't cheating after all.

Which is the perfect moment: the eight-year-old leaves, and the grown-ups lean in. Because what FIFA does with that 495 is the real magic — and it's exactly the part he'd have found boring. So, just us from here.

There are 495 different possible lineups of which groups' thirds qualify. Not "495 matches" — 495 different situations the tournament might find itself in. And for every single one of those, someone has to seat the eight kids in the eight chairs — by the rule, before the tournament even starts.

The bit nobody expects: there are thousands of correct answers

Here's where I thought the puzzle would be "find the one valid seating." It is not.

Take any one of those 495 lineups and count how many legal seatings exist — every way to put the eight kids in the eight chairs with nobody in their own-letter chair. I expected a handful. I wrote a tiny program to count them.

The answer, depending on the lineup, is somewhere between 14,833 and 24,024.

Not 14. Fourteen thousand.

The "don't sit in your own chair" rule sounds strict, but with eight chairs it barely narrows things down at all. Every single one of those 495 lineups has tens of thousands of perfectly fair seatings.

Which raises the real problem — and it's not the one I expected:

The hard part isn't finding a fair seating. It's getting the whole planet to agree on the same fair seating, in advance, with no arguments.

Think about everything that's already printed before a ball is kicked: TV schedules, which city hosts which match, ticket stubs, the path each team would take to the final. You cannot have a referee deciding on the night which of 14,000 fair brackets to use. Imagine the conspiracy theories.

So FIFA does the only sane thing. For each of the 495 possible lineups, they pick one seating ahead of time, write it down, and publish it. That document is real, and it has a wonderfully boring name.

Annexe C: the answer key

It's called Annexe C, and it's in the official tournament regulations. It is, quite literally, a table with 495 rows — one for every possible lineup — and you just look yours up.

I pulled the actual PDF and decoded it for the predictor I built (more on that below). The columns are the eight waiting winners:

Option | 1A | 1B | 1D | 1E | 1G | 1I | 1K | 1L

1A means "the match where the winner of Group A is waiting." Each row tells you which third-place team gets sent there. Here's the real Option 1 — the lineup where the thirds happen to come from groups E, F, G, H, I, J, K and L:

Winner waiting	1A	1B	1D	1E	1G	1I	1K	1L
Third sent there	3E	3J	3I	3F	3H	3G	3L	3K

Read it like a kid reads it: the winner of Group A will play the third-place team from Group E. Winner of B plays third of J. And so on. Check the rule — no column ever sends a team into its own letter. 1A never gets 3A; 1G gets 3H, not 3G. Every row of all 495 obeys it. (I checked all of them by machine. Zero violations. It's a beautiful piece of work.)

That's the entire trick my son thought was cheating:

The bracket shape is fixed forever. Eight chairs, in known places.
Only the names are unknown.
There are 495 possible name-situations.
Each one has thousands of fair answers, so FIFA pre-commits to exactly one and publishes the answer key.
On the night the groups finish, you don't compute anything. You read one row out of a book everyone already agreed on.

Where I came in: the developer footnote

I didn't go down this rabbit hole for fun. I build Quizzy, and one of its toys lets you predict the whole World Cup bracket before it happens. To grade your predictions, my code has to do exactly what FIFA does: take your eight predicted third-place teams and seat them in the eight chairs, correctly.

The lazy instinct is "write an algorithm that finds a valid seating." But Annexe C taught me the lesson the chairs taught my son: there are thousands of valid seatings, and my answer has to match FIFA's exact one, or a user's bracket would diverge from reality. So I don't compute it. I ship the real 495-row table and look it up — the same answer key, byte for byte.

There's one genuinely tricky wrinkle, and it's the same trap as the free kid. While someone is still filling in their bracket, they might have picked only three or four thirds, not all eight. The lookup table only knows about complete sets of eight. So for a half-finished bracket I can't use the book at all — I fall back to live, careful seating (the computer-science name is bipartite matching, but really it's just "seat the kid with the fewest choices first, and back up if you get stuck"). The moment all eight are chosen, I switch back to FIFA's official answer key.

Two different tools for two different moments. The chairs game predicted both.

The end of the afternoon

My son missed all of this — the 14,000 fair brackets, the answer key, every bit of it. He'd taken the one answer he came for (the chart isn't cheating) and gone back to the Lego.

And that's the right instinct, really. The stuff he tapped out of — the formula, the 495, the table — is just the packaging. The lovely thing is the idea inside it: that you can take something genuinely unknowable — which eight of the twelve teams will scrape through in third, out of all the ways a 48-team tournament could possibly unfold — and tame it completely, in advance, with nothing but a printed list and one stubborn rule. No team ever plays its own group. Everything else falls out of that single line.

Then he reappeared at my elbow, half-built Lego stadium in hand, with one more question — and of course it was the only one that actually matters.

"Daddy… so who's going to win?"

That's the beautiful catch. Annexe C has 495 rows and a fixed, fair answer for every possible way the groups can fall; months ahead of time, it can tell you exactly who plays whom. It cannot tell you the one thing my son — and the rest of the planet — actually want to know. That part, thank goodness, you still have to play.

If you want to test your own bracket against the real Annexe C — half-finished or complete — that's exactly what the Quizzy World Cup predictor does. The dining chairs are optional.

Make any quiz with AI in 30 seconds — and the three attempts it took to ship it

Rahul Devaskar — Wed, 20 May 2026 12:32:24 +0000

The sleepover

It was a Saturday afternoon. My son had friends coming over for a sleepover that night, and he wanted to host a quiz. I had said I'd help him build one. I had also told my partner I'd finish something else by 5pm.

The two promises were not compatible. (A typical excuse, I know.)

I sat down at the laptop and thought: just ask the AI. I opened ChatGPT and typed:

Create a 10 question quiz for 8 year old kids with a Minecraft theme. Only expert Minecraft players should get 100%. Make it tough.

Twenty seconds later I had a quiz. My son was reading the questions over my shoulder, suspicious.

"But but but but daddy — how will the AI know what I want?"

He was eight, and he was already asking the question every product manager eventually asks: who is in charge of the requirements here?

I showed him the prompt. I changed "Minecraft" to "Pokemon" and re-ran it. He watched a new quiz appear. He didn't say anything, but he tilted his head in the way he does when he's reconsidering whether something is magic.

That was the moment I thought: this should be a feature in Quizzy.

The cost wall

The naive version is two afternoons of work. Slap a form on a page, send the user's input to an LLM, render the result.

The problem is the bill.

If I put my OpenAI key behind every user, I am paying for every quiz on Quizzy.earth. The economics of a free product where every action calls a paid API are bad in a predictable way: the more successful you are, the more it costs you. There's no version of "this took off" that isn't also "I am broke."

Quizzy doesn't charge for this. I don't want it to. So the question wasn't how do I add AI? — it was how do I add AI in a way where the user's AI does the work?

That turned out to be the hard part. I tried three things.

Attempt 1: The BYO-AI form

The first idea was the obvious one. Build a small form: topic, difficulty, language. Press a button. The app composes a prompt you can copy.

You paste that prompt into whichever AI you already use. ChatGPT, Claude, Gemini, whatever. The AI spits out JSON. You paste the JSON back into Quizzy. The app parses it into a quiz.

In theory: elegant. The user pays for their own tokens. I pay for nothing. Everyone wins.

In practice: I was the only person on Earth who could use it.

The first problem was that most people don't know what JSON is. I had built a flow that required users to understand a serialisation format, and most of them weren't going to. I figured I could explain that part.

The second problem was the one I didn't see coming, and my son was the one who found it.

I handed him the laptop to try it. He typed his topic into Quizzy, copied the generated prompt, pasted it into ChatGPT — and the moment the AI started typing, he selected the half-written response and pasted it back into Quizzy. He didn't wait for the stream to finish. Why would he? On every other app he uses, when text appears, it's done. He pasted half a JSON object, hit create quiz, and got an error.

He looked up at me. What did I do wrong?

He hadn't done anything wrong. The product had. If an eight-year-old can't build a quiz with this thing in under a minute, the product has failed — that was the rule I'd written down for Quizzy on day one, and I'd just watched it break in front of me. Even a kid should be able to build a quiz without friction.

I had built a feature for developers and shipped it to families.

Attempt 2: The magical disappear

The next idea was genuinely fun to think about.

What if the AI itself sent the quiz back to me?

The flow in my head:

The user gets a prompt with a unique ID baked into it.
They paste it into their AI.
The AI generates the quiz and POSTs the JSON to /api/generate-quiz along with that ID.
My backend stores it in Redis under that ID.
The frontend has been polling (or sitting on a websocket) the whole time. The moment the ID lights up, the quiz appears.

The user does nothing. They paste a prompt, they watch their AI think for a few seconds, they look back at Quizzy and the quiz is just there. No copy. No paste. No JSON.

This would have been magic.

It didn't work because, as it turns out, most AI agents won't POST to an arbitrary URL. Some block it outright. Some require a tool the user hasn't enabled. Some quietly refuse. The version of this that works in 2026 is not the version of this that works for a stranger using whichever AI they happen to have open.

Maybe one day. Not yet.

Attempt 3: The URL smuggle

If POST is forbidden, what about GET?

Most AI agents will "browse" or "search" a URL when asked. So what if the prompt told the AI to construct a URL where the entire generated quiz lived in the query string, and then to visit it? My server would parse the quiz out of the query params, stash it in Redis, same as before.

I built this one. It almost worked.

It died for two unromantic reasons. The first is that browsers and proxies cap URL lengths somewhere between 2k and 8k characters. A ten-question quiz with four options each blows past that without breaking a sweat. The second is that the AI's built-in browser tools have their own opinions about what counts as a legal URL, and a 6k-character query string was not one of them. The requests never landed. The DNS resolved to nowhere useful. I was smuggling air.

So: I couldn't hide JSON. I couldn't avoid the copy-paste. And on mobile — where most of Quizzy's traffic actually lives — every paste also means switching apps. Open Quizzy, copy prompt, swipe to ChatGPT, paste, wait, copy response, swipe back, paste again. App-switching on a phone is its own friction tax, and unlike the others, this one I couldn't engineer my way out of in this version. The user's AI is in a different app from mine, and the path between them runs through the OS.

So the remaining question was a smaller one: with all of that fixed in place, could the existing flow at least stop being a UX punishment?

What I actually shipped

The thing I keep reminding myself when I build for people who aren't developers: users don't want your product. They want the thing your product gives them. Every step you can absorb so they don't have to think about it is the product.

I couldn't remove the copy-paste step. But I could make it forgive almost anything.

Two changes did most of the work:

JSONL instead of JSON. Instead of asking the AI for one big JSON array, I ask it to emit one JSON object per line. Now if a user pastes a partial stream — three lines out of ten — I get a three-question quiz instead of an error. Their copy is imperfect; the parse is graceful. The quiz that appears is a little shorter than they expected, not a red banner.

jsonrepair for everything else. Users don't just paste the JSON. They paste the AI's whole response — including "Sure! Here's your quiz:" at the top and "Let me know if you want me to tweak anything!" at the bottom. The jsonrepair package is forgiving in exactly the ways an LLM's output is messy. It strips chatter, closes unclosed brackets, repairs trailing commas, fixes single quotes. It turns "almost JSON" into JSON.

Together: the flow still has a paste step, but the paste step almost never fails. The user sees a quiz appear. They don't see the parser stitching their messy paste back into shape.

It is not the magical disappearing-prompt flow I wanted in attempt two. But it ships, it costs me nothing per quiz, and it works for grandparents pasting from ChatGPT on a Sunday morning.

The thread

Every dead end I hit was a version of the same instinct: let the user's tools do the work. That instinct was right. The trick wasn't backing away from it — it was accepting that the rough edges of "the user's tools" (partial pastes, friendly preambles, half-streamed responses) were my problem to absorb, not theirs.

Good UX, in this case, looked less like a clever pipeline and more like a tolerant parser. The clever architecture would have been more satisfying to build. It also wouldn't have shipped.

Try it — and tell me how you'd do it

It's live at quizzy.earth. Open it, pick a topic, generate the prompt, paste it into your favourite AI, paste the response back. Thirty seconds, no account, your tokens.

If you've solved "great UX on someone else's API budget" in a way I haven't tried — I'd love to hear it. Especially that magical disappearing version. I still think there's a way to make it work.

I built a quiz app with my 8-year-old to fix homework — and accidentally a family ritual

Rahul Devaskar — Thu, 14 May 2026 10:02:32 +0000

The homework problem

It started in December 2025.

My son was about to start Year 3, and Year 3 in Australia means NAPLAN — the standardised test that suddenly turns "reading at bedtime" into "structured practice." I had a stack of worksheets, a pile of flashcards, and a kid who had zero interest in any of it.

The problem wasn't that he couldn't do the questions. He could. The problem was that being asked the questions felt like a chore. The format was the friction. A worksheet says: here is work. A timer on a phone says: here is a game.

So one evening I sat down with him and we made a deal: I'll build a thing that turns your homework into a quiz game, and you tell me what makes it fun.

That deal is what eventually became quizzy.earth.

What an 8-year-old taught me about UX

Here is the thing nobody tells you about designing for kids: they have zero patience for your onboarding flow.

I tried existing tools first. They all had the same shape:

Sign up
Verify your email
Create an account name
Click through a tutorial
Now you can make a question

By step 2 my son had wandered off to find his ipad.

He wasn't being difficult. He was telling me something true that adults have learned to tolerate: most software treats the act of starting as a tax you pay before the fun begins. For a kid, there is no "before the fun begins." There is just fun, or there isn't.

So the first rule wrote itself: no sign ups. Open the page, type a question, press play. If a Year 3 kid can't make a quiz in under a minute, the product has failed.

The second rule came from watching him try to type. He could read fluently, but typing a multiple-choice question with four options and marking the right one is a lot of fiddly UI. Every dropdown, every modal, every "are you sure?" was a place he would stall. So we ripped them all out. One screen. One question at a time. Big buttons. The kind of UI where you don't have to read the labels to know what to press.

The third rule was the hardest, and I didn't see it until later.

"Can we play the toy quiz again?"

Once the prototype worked for homework, something unexpected happened.

We had family over for dinner. My son — who two weeks earlier hated structured anything — opened the laptop and announced he was going to host a quiz about his soft toys. He'd made it that afternoon. Without telling me.

The first question was "What is the name of the brown and white teddy?" — and four adults around a dinner table started arguing about a teddy bear's name like it was trivia night at the pub.

That was the moment I realised the thing I'd built wasn't a homework tool. It was a tool for shared attention. Homework was just the excuse.

The problem it actually solved had nothing to do with NAPLAN. It was: how do you get a group of people — kids and adults, different ages, different attention spans — to look at the same thing and laugh together for ten minutes?

Most "family games" require somebody to read instructions out loud, deal cards, keep score, and referee disputes. By the time you've set it up, the four-year-old has lost interest. A quiz on a screen, hosted by a kid, sidesteps all of that. The kid is in charge. The adults are players. The screen does the scoring. The friction is gone.

The grandparents problem

The next wedge came from a phone call.

My parents — the grandparents — had been hearing about the dinner quizzes. They wanted to play. But they live overseas, and the "everyone in the same room" format obviously doesn't work over a video call with lag and three time zones.

What they wanted was something different: a quiz they could play alone, at their own pace, when they had a quiet moment.

This was a real shift. The original product was synchronous — one host, many players, one room. What they were asking for was asynchronous — make a quiz, send a link, the other person plays whenever, you see how they did later.

And the delivery channel wasn't an app. It wasn't email. It was WhatsApp. Because that's where the family already was.

This is the part I keep coming back to when I think about building things: users don't show up where you want them to show up. You go to them. The grandparents weren't going to download an app, create an account, or learn a new interface. They were going to tap a link in WhatsApp and play. If you can't meet them there, you don't have a product for them.

So we built that mode too. Same engine, different shape: make a quiz, get a shareable link, send it through whichever group chat your family lives in, and the recipient plays solo. The host gets to see the results. No accounts. No friction.

The thread

If I zoom out, every version of the product has been solving the same underlying problem in different clothes:

Homework: how do I get a kid to engage with content that feels like work?
Dinner table: how do I get a mixed-age group to share attention for ten minutes?
Grandparents over WhatsApp: how do I share a small moment of play with someone who isn't in the room?

The answer in all three cases turned out to be the same: strip the friction until the activity itself is the only thing left.

No accounts. No tutorials. No app store. No "set up your profile." Just: here is a question, here are the answers, press the one you think is right.

It sounds obvious written down. It was not obvious while I was building it. Every time I added a feature, my son would find a way to get stuck on it, and I'd take it back out. He was, without knowing it, the most ruthless product reviewer I've ever worked with.

What I'd tell someone starting a side project

Three things, in order of how badly I wish I'd known them earlier:

1. Find a user who can't be polite to you. Adults will tell you your product is "interesting" and never open it again. An eight-year-old will tell you it's boring and walk away mid-sentence. The second kind of feedback is worth ten times more.

2. The problem you start with is not the problem you end up solving. I started with homework. I ended up with a thing my parents use to send their grandkids quizzes from the other side of the world. The interesting product was hiding inside the obvious one.

3. Friction is the feature. Or rather, the absence of it is. Every screen you remove, every account step you delete, every "are you sure?" you cut — those aren't simplifications. Those are the product.

If you want to try it, it's at quizzy.earth. No sign up. Make a quiz in a minute. Send it to whoever you want to laugh with.

And if you have a kid in Year 3 staring down a stack of worksheets — open it, hand them the keyboard, and see what they make. They'll surprise you.