PCx · Product & Platform Design · self-directed work sample

One question, answered every morning

4 gated stages · 1 task engine · the ranking rule readable inside the screen it governs

The question

A founder sent over the planning documents for PCx. It is a platform meant to carry a real-estate agent from their first week to a full book of business. With them came one blunt question about the Career Path Builder. The documents had been written in two rounds. Read side by side, they described two different products.

Stage names disagreed. So did completion rules, and whether a "Productive Agent" was a career stage or a separate production level. Nine contradictions in total. None could be settled by picking the version that sounded best. Each needed a rule for which source wins, and why.

So I set myself a goal: make the concept tangible enough to argue with. Not a slide describing a career path, but something you can open on your phone, act inside, and watch change. And it had to be honest about which ideas came from the platform and which were mine.

Constraints: Working prototype only, with sample data and no server. One HTML file, no build step. The sources conflict and must not be quietly merged. Every mechanism the sources did not specify is labeled as a proposal.

How it was made

  1. 1 · Discovery
  2. 2 · Strategy
  3. 3 · Concept
  4. 4 · Design
  5. 5 · Production
  6. 6 · Verification
  1. Discovery

    The source read like two products with one name. Two rounds of thinking, stacked on top of each other. They agreed about the platform. They did not agree about the career path. So the first thing I made was a list, before any design: nine places where they clashed, each traced to its source.

    Two stacked document strata, older and newer, with nine numbered contradiction markers drawn between them and lines mapping each marker back to its source section
    1. Two sets of documents arrived about the same product.
    2. Read on their own, each one made sense.
    3. Side by side, they disagreed in nine places.
    4. So the first thing I built was the list of disagreements.
    Nine contradictions, each mapped to the line that produced it.
  2. Strategy

    One rule settled most of them: the founder's most recent dated note wins, and no round of thinking gets quietly blended into another. Two I left open on purpose. They were his call, not mine. Then the harder rule. Anything the sources did not spell out got marked as my idea, in writing.

    Two labeled columns divided by a vertical wall: source principles on the left paired by arrows to proposed implementations on the right
    1. Everything the platform already believed went on the left.
    2. Everything I was proposing went on the right.
    3. A wall between them, so nobody has to guess whose idea was whose.
    The attribution wall. Their principle on one side, my proposal on the other.
  3. Concept

    The daily Home screen went through three shapes. Sort by priority alone, and a low-priority task that was not due yet jumps ahead of today's work. Show every course at once, and you get a list nobody can explain. The shape that won: group by how urgent it is, sort inside each group, and put the rule on the screen.

    Three home-screen sketches side by side; the first two struck through with annotations explaining why they were rejected, the third showing five stacked urgency bands and a why-is-this-first link
    1. First try: sort the day by priority alone. A low-priority task that was not due yet jumped the queue.
    2. Second try: show every course at once. The result was a list nobody could explain.
    3. Third try: group by urgency first, and sort inside each group.
    4. Then put the rule on the screen, so the order can be questioned.
    Two rejected Home models, annotated, and the one that shipped.
  4. Design

    Three screens, one shared set of facts, no server. An agent's ranked day, with the ordering rule right there to read. A leader's queue where one approval finishes the course, opens the next stage, and re-sorts the agent's day. A builder whose published versions stay frozen for anyone partway through.

    Three browser frames: agent home, leader verification queue, career path builder. One traced event path connects them, running from a leader verification through certification conclusion and gate opening to a re-ranked agent home
    1. Three screens, all reading from one shared set of facts.
    2. A leader approves one submission.
    3. That single approval finishes the course and opens the next stage.
    4. And the agent's list quietly puts itself back in order.
    One verification, four state changes, three screens.
  5. Production

    The build was never allowed to grade itself. Four automated passes went over it, each looking for something different, and none could see another's findings. Every finding got one of three answers: real and fixed, not real and why, or real and knowingly accepted. Nothing was dropped in silence. One pass caught a gate missing its own prerequisite.

    A closed review loop from build through four separate automated review passes into a three-way triage: confirmed, rejected with evidence, or disclosed trade-off, and back to fix and re-verify
    1. The finished work went out for review.
    2. Four separate automated review passes, each looking for something different.
    3. Every finding had to be given one of three answers.
    4. Real and fixed, not real and why, or real and knowingly accepted.
    5. Then round again, until a pass with nothing left to find.
    Findings enter, dispositions exit, nothing disappears.
  6. Verification

    Verification was written as code, not opinion. A script drove the real controls: mouse, touch, keyboard, reduced motion, and hostile text. It ran on a laptop and on a phone. Every page that went out had to match its source character for character. One claim proved false. I fixed it and left it on the record.

    A verification sheet: a checklist of passed interaction and style assertions on the left, rows pairing matching truncated SHA-256 hashes on the right, and a struck-through corrected claim preserved at the bottom
    1. A script did the checking, so it could not be talked out of a result.
    2. Every delivered page had to match what I wrote, character for character.
    3. Identical, not just similar.
    4. One claim turned out to be false. It was corrected and left on the record.
    Checks a computer can run and grade, and deployments proven by hash.

The deliverable, live

This is the working deliverable itself, not a mockup of it.

Open full screen ↗

How it was verified

  • 7 of 9Source contradictions settled on a dated rule. Two were the founder's call, not mine
  • 40 of 41Recorded decisions that name the alternative they rejected
  • 16Acceptance flows specified, each with a named forbidden regression
  • 3 of 3Delivered pages byte-identical to their source, checked with a fingerprint that changes if a single character does

The question in the founder's email

"What should I do today?"

The question the Home screen had to answer, from the email that came with the files