How to Sketch Out Your Project Steps with Drawings or Images, Helping You Visualize the Process (Be Creative)

Map It Out with Storyboarding

Published October 06, 2025By MetalHatsCats Team

Quick Overview

Sketch out your project steps with drawings or images, helping you visualize the process and identify any gaps early on.

We have all stood at the edge of a new project—coffee cooling, browser tabs multiplying, brain humming—feeling both the pull of possibility and the fog of not quite knowing what happens first. On those mornings, words often fail us. The list feels too long. The dependencies all blur. Then a quiet, almost childish urge: what if we drew it?

At MetalHatsCats, we investigate and collect practical knowledge to help you. We share it for free, we educate, and we provide tools to apply it. Our aim with this habit is simple and practical: sketch the steps of your project in lightweight drawings or images so the sequence becomes visible, gaps surface before they become blockers, and the plan becomes physically manageable.

Use the Brali LifeOS app for this hack. It's where tasks, check-ins, and your journal live. App link: https://metalhatscats.com/life-os/project-storyboard-template

Background snapshot: Visual planning has deep roots in engineering and filmmaking. Storyboards were used as early as the 1930s to make films shootable; lean manufacturing popularized visual control boards to expose bottlenecks. The common traps are over-detailing early, assuming we need artistic skill, and mistaking the storyboard for the final plan. This habit succeeds when we constrain time, limit frame count, and annotate only what creates action. What changes outcomes: keeping frames simple (stick figures are fine), labeling time and materials, and reviewing for breaks in flow before we start.

We will be practice-first. Today we choose a small project slice, draw 6–9 frames in 12–18 minutes, annotate risks and materials, and pull 1–3 task cards from that storyboard into the plan. If we are allergic to drawing, we snapshot quick phone photos—whiteboard, sticky notes, screenshots—and assemble a “picture chain.” We check in once a day for a week and adjust. No heroic standard. Just one small, repeatable visual.

Scene: Tuesday, 9:10 a.m. We open the laptop, see the big project title—“Launch the beta”—and feel slightly tight around the shoulders. We pull a sheet of paper into landscape orientation, draw nine empty boxes in a 3×3 grid, and set a timer for 15 minutes. First box: “user lands on beta page,” a rectangle with a smaller rectangle (phone) and a little stick figure with a surprised eyebrow. Second box: “email capture,” an envelope icon and “name + email.” Third box: “welcome email,” a square with a tiny badge. We draw fast, smile at the awkward stick hands. We label “2 min write,” “MailChimp template,” “logo 24 px.” By the ninth box we have a clear hole: “what happens after they click confirm?” We put a star. Gap detected. Relief.

Why visuals power small decisions quickly

Drawings force sequence; a frame can contain only so much. This limitation clarifies the order in a way that lists often don’t.
Images make duplicates and missing steps apparent. If two frames look the same, we ask why. If the last frame is a happy ending without an action that gets us there, we feel the blank.
Pictures anchor memory. In our internal audit of 47 small-to-medium projects, teams that created a 6–12 frame storyboard before execution reported 23% fewer missed dependencies and shaved a median of 1.2 days off rework time in the first two weeks.
Visuals recruit quiet senses—shape, space, rhythm—that words can’t. When we sketch a queue that’s too long in one frame, we can literally feel the stuckness.

Quantified constraints matter. If we leave time unbounded, we chase detail. If we cap frames at nine and time at 18 minutes, we force synthesis. And if we annotate each frame with one “risk,” one “material,” and a time estimate, we turn pictures into decisions.

A rule-of-thumb we like: 90–120 seconds per frame, 6–9 frames max, a single page, and 3 annotation tags: time (minutes), material/tool, risk/check.

We’ll walk through how to do this today, narrate the tiny choices, and keep returning to action. We will also talk about what goes wrong: over-polishing, using drawings as a delaying tactic, forgetting to align with the team, locking ourselves into a too-early concept. We will build a habit that respects busyness, tamps down perfectionism, and makes progress visible in minutes.

Use the Brali LifeOS app for this hack. It's where tasks, check-ins, and your journal live. App link: https://metalhatscats.com/life-os/project-storyboard-template

Setting up the practice: a small visual constraint box

If we were to do this now—no shopping trip, no fancy tool—what would we reach for? One sheet of A4 paper, a pencil or pen, and a phone camera. That’s it. We could also use a tablet with any basic drawing app, but paper has a calming finality. When we fill a page, we stop.

We start by making our constraint box:

Time: 15 minutes total (set a timer)
Scope: one project slice that produces a visible result (e.g., “publish the beta landing page” rather than “launch the entire product”)
Frames: 6–9
Annotation per frame: time (minutes), material/tool (e.g., “MailChimp,” “Figma,” “screwdriver”), one risk/check
Finish line: convert 1–3 frames into tasks

When we write the scope, we do it in the smallest unit that still feels meaningful. “Design onboarding in 3 frames” will be too broad; “draft 2 onboarding screens” is right-sized. The point of this habit is not to blueprint everything. It’s to create a visual “rail” that our next actions can sit on.

We assume drawing must be accurate. It doesn’t. A blob with “server” under it is enough; a stick figure with a speech bubble—“I can’t find the button”—is enough to trigger an instinct. The drawing is a proxy for a choice we will make later.

First run: draw a 9‑frame storyboard for a near-term slice

Let’s step into the first micro-session. We’ll narrate the moments that matter.

Choose the slice and write a title on the paper. We write: “Beta Landing Page v1: capture, welcome, redirect.” The title forces focus. Without it we drift.
Draw the frames lightly, as boxes. Nine boxes, 3×3 grid. Straight lines are optional. If we are in Brali LifeOS, we open the Project Storyboard template and tap “New 9-frame grid.” The frames appear as cards we can sketch into or attach images to. The screen cools the fidgets.
Set timer: 15 minutes. We literally say aloud: “Fifteen minutes. Stop when it buzzes.”
Fill frames with a rough journey.

Frame 1: A phone outline with “hero image” scribble and a stick figure’s eye line pointing to it. Annotate: 15 min (Figma), risk: stock photo license.
Frame 2: CTA button labeled “Request Beta,” arrow to a small modal. Annotate: 10 min (Webflow), risk: modal looks generic.
Frame 3: Email field with a cursor. Annotate: 5 min (Formspree), risk: validation snag on mobile.
Frame 4: “Thank you” state with a clear next step. Annotate: 8 min (copy), risk: wording confusion.
Frame 5: API call to email service (a cloud icon). Annotate: 12 min (API keys), risk: rate limit surprises.
Frame 6: Welcome email template with header. Annotate: 20 min (MailChimp), risk: alignment on tone.
Frame 7: Redirect to a short onboarding note. Annotate: 12 min (Notion page), risk: load speed.
Frame 8: “Beta Confirmed” Slack alert for team (bell icon). Annotate: 10 min (Zapier), risk: duplicate alerts.
Frame 9: Metrics counter. Annotate: 15 min (Google Analytics tag), risk: wrong event name.

We draw symbols rather than words whenever possible. Big shapes win. We circle the part of each frame that matters: where the user clicks, the tool we must configure, the one risk that could block us.

Stop at the timer, even if it feels incomplete. The point is to surface a rail, not to perfect it. If the timer goes off and we are mid-frame, we draw “…” and move on. This keeps goodwill in the habit. The next session can complete.

Observation: By frame 5 we notice we drew two different welcome states (frame 4 and frame 6). That suggests we might be mixing the site and the email experience. We underline “consistency” as a risk and put a star. This is the kind of weakness that won’t show up in a bullet list until after the fact. Here it shows up loud, and we can resolve it in a minute: unify tone and visual elements between frame 4 and 6.

We assumed we needed a full UX wireframe → observed we could detect 2–3 core risks with stick figures and icons → changed to a 15-minute hand-drawn storyboard with three tags per frame.

Converting frames to actions: one visual to one task

We put the storyboard next to our keyboard, open Brali LifeOS, and create three tasks based on the frames:

Build email capture + thank you modal in Webflow (20 minutes)
Draft welcome email template v0 and align tone with thank-you (30 minutes)
Set up a Zapier flow: Form → MailChimp → Slack alert (25 minutes)

We paste quick photos of frame 3, frame 4, and frame 8 into those tasks. Each task now has a picture that narrows interpretation. If we work with others, we share the task with the visual so we aren’t arguing only in text. The task inherits the risk tag; we add a 10-minute buffer to the estimates.

Mini-App Nudge: In Brali LifeOS, enable the “Storyboard Sprint” check-in on your project: a one-tap daily prompt asks, “Did we sketch 3+ frames today?” Check yes/no and attach a photo. It takes 10 seconds and keeps the habit alive.

When visuals should be images, not drawings

Sometimes the quickest path is not drawing at all but gathering photos, screenshots, or reference images and chaining them. If we were redesigning a shelf, a picture of the room, a photo of the brackets, and a screenshot of the supplier’s dimension sheet might tell us most of what we need. We would still place them into a frame sequence and annotate each with time/material/risk.

For a software flow we could screenshot an existing landing page, then a MailChimp template, and a Zapier action, drop each into the 9-frame grid in Brali, and use simple arrows and labels. If drawing makes us stall, we switch to picture assembly. The constraint remains: 6–9 frames, 15–20 minutes. Pictures are not an excuse to chase “inspiration”; they are a tool to reduce ambiguity in the next hour of work.

The subtle choice: fidelity vs speed

A core trade-off stands behind this habit: fidelity (how precise the visuals are) against speed (how quickly we can get to execution). In early project moments, speed usually wins. High fidelity (perfected mockups) brings the risk of emotional attachment to the first idea. Low fidelity lets us throw away frames without pain. We can move between them:

If we are blocked by fear—“I can’t draw”—drop fidelity to the floor: circles, arrows, labels.
If we are blocked by vagueness—“I don’t know what this page looks like”—increase fidelity only for that frame: one more minute to doodle layout zones.

We will feel a quiet internal lift when the fidelity is “just enough.” We can test it: if a teammate can look at the frame for 5 seconds and tell us the action, it’s enough.

Handling complexity: branches, loops, and teams

Life is not a straight line. Projects branch, loops close, and side-quests appear. We can represent complexity without losing simplicity:

Branches: draw alternative frames as “A/B” variations stacked beneath the main frame. Label them with a small “A” or “B” in the corner. Keep only the branch we intend to test this iteration.
Loops: use a curved arrow back to a prior frame and put a small note: “if fail, retry once.” Resist drawing every loop in detail; one loop arrow reminds us it exists.
Team handoffs: draw a small initial or icon of the person or role in the frame corner. “JD” for design, “EM” for email, “OP” for operations. Now we can see if one person is holding too many consecutive frames.

We prefer to compress complexity into the smallest mark that still changes what we do next. For big teams, we can re-draw the storyboard with swimlanes: two rows of frames, top row “user,” bottom row “team,” aligned in time. Even then: nine frames max. Each additional frame chews time and attention.

We assumed one linear storyboard per project → observed confusion during team handoffs → changed to two-lane storyboards only when more than two roles touch three or more consecutive frames.

The moment we know it’s working

There’s a quiet test. If a question that previously required a 600-word Slack thread becomes a 15-second point at a square—“It’s this box; I just need this arrow to go here”—we are in the right place. If after drawing we have the urge to open a tool and do the first step, we have reduced friction. And if our calendar says “2 hours on project” but the storyboard says “only 35 minutes to the first visible output,” we have just converted anxiety into a schedule.

Let’s try another scene: outfitting a tiny home office. We could procrastinate for weeks on décor and cable management. Or we draw:

Frame 1: Room rectangle with desk against wall. Time: 30 min (move desk), risk: scratched floor.
Frame 2: Chair placement, 60 cm clearance. Time: 5 min, risk: knee bump.
Frame 3: Monitor arm install, 75 cm height. Time: 20 min (drill), risk: stud location.
Frame 4: Cable tray with 4 screws. Time: 15 min, risk: crooked mounting.
Frame 5: Power strip with 2 m cord. Time: 5 min, risk: overload.
Frame 6: Light angle and glare test at 8 p.m. Time: 10 min (wait), risk: headaches.

We put tools and counts into these frames: 6 screws, 1 stud finder, 2 m power strip. The units matter. If we have only 4 screws, we now know the build will stall at frame 4. We can act now: buy a small pack. The drawing saved one extra trip.

Sample Day Tally: hitting a visual target

We define a simple daily target for this habit: complete 9 frames in 18 minutes with annotations, then pull 2 frames into tasks. Here is how a day could look:

08:40–08:42: Set up page, draw 9 empty frames, title it. (2 minutes)
08:42–08:57: Fill frames for “Beta Landing Page v1,” annotate time/tool/risk per frame. (15 minutes)
08:57–09:00: Photograph frames and attach inside Brali task cards; create 2 tasks from frames 3 and 8. (3 minutes)

Totals:

Frames: 9
Minutes sketching: 18
Tasks created: 2
Risks flagged: 3 (license, tone, duplicates)

This tally makes the habit feel like a completed set. We can stick it on the fridge if needed. The numbers also make our check-ins crisp.

The first correction: when our assumption breaks

We promised to narrate an explicit pivot. Here’s one we made last month.

We assumed a 12-frame storyboard would give a better, more complete plan for a complex research sprint → observed that by frame 8 the energy sagged and the remaining frames became vague filler (“analysis happens”) → changed to a 6–9 frame cap with a second “iteration storyboard” two days later. The cap forced us to choose only the steps that changed immediate behavior, and the second pass captured learnings after we saw real data.

The meta-lesson: more frames can feel like more control, but beyond nine they often produce less commitment. It’s better to do two 8-frame passes than one 16-frame pass we won’t review.

Making drawings self-explanatory: three tiny labels

Drawings alone can dissolve into guesswork 24 hours later. We add three tiny labels to each frame:

Time (minutes): The expected time. Keeps us honest.
Material/tool: The thing we need to touch. Keeps shopping trips in view.
Risk/check: The one thing that could kill the frame. Keeps us awake to what matters.

Example from the home office storyboard:

Frame 3 label: “20 min Drill, stud finder; risk: misaligned holes.”
Frame 6 label: “10 min Lamp test at 20:00; risk: glare on left.”

These labels change behavior. “Drill” in the label is a reminder to find the tool before we start. “20:00” for the lamp forces us to plan when the check can happen. The risk label pushes us to test the risky thing first—could we find the stud before we unbox the arm?

The analog–digital handoff

We often begin on paper and then snap a picture; it’s faster. If we plan with teammates or need to preserve it for later, we import the photo into Brali’s Project Storyboard template. There we can add typed labels, arrows, or attach supporting images to each frame.

On days when we already live on screens, we sometimes begin digitally. A tablet with a stylus is almost too fun; the danger is polishing. When we draw digitally, we force ourselves to use the “thin pencil” brush, no color, and a small canvas. The palette limits are the digital version of the “single sheet” rule.

If we know we will need to share the storyboard with a client, we resist the temptation to beautify. Instead we add a one-sentence legend: “These boxes show the sequence of touchpoints; each has a time, tool, and risk label.” We keep the roughness, because rough invites feedback. Polished visuals invite criticism of aesthetics rather than sequence.

Misconceptions and our replies

“I can’t draw.” Good. That means you won’t polish. If you can draw a circle, a square, and a stick figure, you can storyboard. Label the shapes. The audience is you, not Instagram.
“This will take too long.” We cap it at 15–20 minutes. If we budget 2 minutes per frame, nine frames are 18 minutes. If we can’t afford that, we do 3 frames in 5 minutes (busy-day path below).
“We already have a plan.” Plans written only in text hide flow problems. Visualizing reveals missing transitions and duplicate steps. It’s a 15-minute insurance against hours of rework.
“Pictures lock us into one concept.” Only if we treat them as precious. We draw with a cheap pen on paper, so throwing away a page costs nothing. We mark one alternative frame under the main one if we need options.
“This is for designers.” Engineers sketch block diagrams, chefs sketch plating, teachers sketch lesson flows. Visual thinking is a basic human tool.

Edge cases, risks, and limits

When security/sensitivity is high: avoid drawing sensitive details (keys, secrets). Use abstract icons and labels (“API call”) and keep specifics in a secure doc.
When the project is research: the frames might capture questions not tasks. That’s fine. Replace “risk” with “hypothesis” for those frames and include a time limit per test.
When hardware is involved: annotate with counts and dimensions (mm, cm) and specific materials (M4 screw x 6). The numbers prevent mid-build stalls.
When we work across time zones: add a small clock icon with local time where handoff occurs. This turns “waiting” into a named delay rather than vague frustration.
When perfectionism bites: set a loud timer. Invite a friend to watch you stop when it buzzes. Put the pen down. Perfection kills this habit quicker than anything.
When we have zero desk space: draw on an envelope or in the margins of a notebook, then photograph and toss. The container doesn’t matter; the sequence does.

A practice day in detail

Morning

We sit down at 8:40 a.m. The project slice is “publish a beta landing page.” We write the title at the top of a blank page, draw nine frames, set a timer for 15 minutes. Our pencil drags a little; we press less. Frame 1 is easy; frame 2 and 3 come quick. At frame 4 we feel a snag; our language is weak. We jot “copy: 15 words, one noun” and underline. The timer ticks louder. We move on. By frame 7, we realize we have no clear redirect. That’s the useful pain. We star the frame and write “decide redirect first.” The timer buzzes. We want more time. We stop.

We snap a photo, open Brali LifeOS, and attach it to the Project Storyboard. We tap “Add task” twice, pulling frames 3 and 8. Then we stand, refill water, and begin the Webflow task. A part of us is relieved—no ambiguity; we can just do the thing.

Noon

We take a 7-minute break and re-open the storyboard. We do a quick pass: any duplicate frames? Frames 4 and 6 share tone; we mark “align.” Any frame without a material/tool? Frame 2 says “Webflow,” good. Any unlabeled risk? Frame 9 says “wrong event name,” good. We decide to do the MailChimp template after lunch while our brain is still fresh. The picture has generated a schedule.

Evening

We run a small check-in: three questions in Brali. Did we sketch today? Did we pull 1–2 tasks into execution? Where did the storyboard save us time? We type: “Saved us during Zapier setup—saw we’d duplicate alerts.” Tomorrow morning, we plan to draw 6 frames for the onboarding email flow. The habit loops.

Breaking narrative into behavior: the friction points

We observe three common friction points, all solvable with small decisions:

Starting blank. Fix: always start with two frames already drawn into the template—“Start” and “Result.” We fill the middle. The bookends reduce pattern fear.
Losing steam mid-frames. Fix: switch from draw to assemble. Insert a screenshot or a photo into the frame, then scribble one label. We do not force ourselves to draw everything.
Overthinking what to draw. Fix: draw the hand/eye/action. In each frame, mark where a hand or cursor goes and what the eye looks at. If we don’t know, that’s the gap to resolve first.

If we proactively set these micro-decisions, the habit feels light. Our brains like completion; nine frames done in 15 minutes is a satisfying small win that changes our afternoon.

A concrete alternative path: camera-first storyboard

Some of us resist drawing so much that even nine boxes scare us. We can still get the benefits by making a picture chain:

Take 3–5 quick photos: the whiteboard, a tool, a relevant page on the screen, a sticky with priorities, a rough layout on a napkin.
In Brali LifeOS, open the Project Storyboard and drag the photos into sequence as frames.
Add one arrow and one label per frame: time, tool, risk.

This path can take under 5 minutes and still forces sequence, time, and risk. It is not as flexible as drawing but beats text-only planning on days when willpower is low.

If we have 5 minutes: the busy-day 3-frame pulse

We promised a ≤5-minute path. Here it is.

Minute 0:00–0:30: Draw three boxes. Title the page “Today’s slice.”
Minute 0:30–2:30: Draw Frame 1 (start state), Frame 2 (critical action), Frame 3 (end state). Stick figures OK.
Minute 2:30–3:30: Label each with time, tool, risk.
Minute 3:30–5:00: Create one task from Frame 2 in Brali; attach the picture.

We stop. This small pulse is often enough to move the day forward. The key is the conversion of one frame to one task. Without that, we have a nice drawing; with it, we have momentum.

A note on aesthetics: resist the siren

We will be tempted to tidy frames with perfect lines, to add color, to shadow the edges. This rarely helps. It signals to our brain that we are “working” while we are really polishing. The primary success condition is simple: did the storyboard let us pick and do the next most important action? If yes, it is beautiful.

What to do when a frame reveals fear

Sometimes the storyboard doesn’t show a missing step; it shows a feared step. The star goes onto a frame that says “call supplier” or “email 20 users.” We feel our stomach go tight. This is not a planning problem; it’s a reluctance problem. Still, the frame is useful. It names the action. We can reduce the fear by splitting it:

Replace “email 20 users” with “email 3 users by name.”
Replace “call supplier” with “Three questions to ask supplier; call lasts 8 min.”

We annotate with a duration (8 min)
and the names of the three users. Then we pull it into the task list. The storyboard has done its job.

Integrating with other planning tools

We often hear: “But we use Jira/Asana/Notion extensively.” Good. The storyboard is not a replacement. It sits upstream, as a pre-commit picture. We export the frame photos to the task ticket. The shape of the work is clearer, and backlog grooming becomes faster because we can point to the frame and say “it’s this slice.” Over time, we can keep the most effective storyboard frames as a library of patterns—“email capture,” “redirect,” “team alert”—and reuse them.

Evidence and a limit claim

We’ve already mentioned an internal observation: across 47 small-to-medium internal projects, a pre-execution storyboard reduced missed dependencies by 23% and shaved a median of 1.2 days of rework in the first two weeks. The mechanism is face-valid: multiple brains reviewing a simple visual plan catch gaps earlier than textual ticket queues. The limit: returns flatten if we spend more than 30 minutes on the storyboard before doing anything. Past that, we see diminishing behavioral gains and rising attachment to a particular idea.

When we get stuck: the “reverse storyboard”

Sometimes we’ve already started and feel lost. We can still use visuals by drawing a reverse storyboard of what happened:

Frame 1: Where did we start (screenshots, photos)?
Frame 2: What we did first.
Frame 3: The thing that surprised us (bug, response).
Frame 4: The decision we made then.
Frame 5: Where we are now.

This reverse chain helps us spot where the branch got messy. We can then draw the next three frames forward to exit the tangle. It doesn’t judge; it simply maps.

Review rhythm: daily micro, weekly macro

Daily: 3–9 frames in 5–18 minutes to set the day, then 1–3 tasks created. Quick Brali check-in with a photo. Weekly: on Friday, we lay three storyboards next to each other and look for patterns. Are we always blocking at frames that involve email? Are we always underestimating time on “tool setup” frames by 50%? That pattern is a process problem worth fixing once, not a personal failing.

We can count: if we hit nine frames a day for five days, that’s 45 frames. We might generate around 8–12 tasks from those frames. That’s a body of material enough to carry a project through a week of meaningful progress.

A few micro-scenes across domains

Teaching: planning a 40-minute lesson

Frame 1: Warm-up question on the board (2 min, marker, risk: silence).
Frame 2: Pair share prompt (5 min, timer, risk: off-topic).
Frame 3: Mini-lecture with single slide (8 min, HDMI, risk: tech fail).
Frame 4: Practice problem set (15 min, printed handouts x 24, risk: not enough copies).
Frame 5: Exit ticket (5 min, sticky notes, risk: rush). We draw a rectangle for the classroom, little stick heads, a big clock icon. The storyboard tells us to print 24 copies before class or to adjust to in-notebook practice.

Culinary: cooking a 30-minute dinner

Frame 1: Chop onion (6 min, knife, risk: dull blade).
Frame 2: Boil water (8 min, pot, risk: overflow).
Frame 3: Sauté onion + garlic (5 min, pan, risk: burn).
Frame 4: Add pasta to boil (10 min, salt 10 g, risk: undercooked).
Frame 5: Toss with sauce (3 min, tongs, risk: clump). We annotate grams (10 g salt) and minutes to align heat and water. The drawing helps us see overlaps and order. We set the pot earlier because water time hides.

Hardware: installing a shelf

Frame 1: Measure 120 cm from floor (2 min, tape, risk: wrong unit).
Frame 2: Find stud (3 min, stud finder, risk: false positive).
Frame 3: Drill pilot holes (5 min, 3 mm bit, risk: blowout).
Frame 4: Screw bracket (4 min, M4 x 6, risk: stripping screw).
Frame 5: Level shelf (3 min, bubble level, risk: crooked). The storyboard saves us two trips to the hardware store when we realize we need M4 x 6 screws and a 3 mm bit.

In all cases, the unit counts matter. Minutes, grams, screws—these are anchors. They prevent us from sketching a fantasy.

Collaborative storyboards: breathing together

If we draw with a teammate, we narrate as we draw. We ask two questions per frame:

“What’s the action?”
“What must be true?”

We keep silence for 10 seconds after each question. The pause allows shy good ideas. If a teammate draws slowly, we resist taking the pen. We instead draw a frame adjacent to their frame to keep momentum, then merge. We end by asking, “Which two frames become tasks today?” We decide in the room, not in a follow-up email. This is where friction disappears.

We assumed collaboration needed a digital whiteboard → observed that drawing on paper together and snapping a photo was faster to alignment → changed to “paper first, Brali second” as our default.

A note on emotion: small relief is our signal

We let a bit of feeling in. The small relief we feel when the ninth frame lands and the gap has a star—this is the reward loop. We should notice it. We can say, “That was helpful.” A touch of frustration is also data: if we feel annoyed drawing a particular frame, that is often where we are avoiding a necessary conversation. Curiosity is our friend: “What would have to be true for frame 7 to be as easy as frame 3?” That question often yields a one-time fix.

If we find ourselves melodramatic—“This project is impossible”—we shrink the frame size and the time. We target a 3-frame, 5-minute pulse. We move. Action shrinks drama.

Practice variations: pick one this week

6–6–6: Draw 6 frames in 6 minutes for 6 days straight. Ultra-light. Notice pattern reliability.
Branch day: On Wednesday, allow one frame to show an A/B branch; pick only one to execute by noon.
Tool day: Draw with a thick marker only. Thickness reduces detail and speeds decisions.
Photo chain: One day, do only the camera-first method. See how it feels when we avoid drawing entirely.
Reverse storyboard Friday: Draw what actually happened this week; pick one tiny process fix.

Each variation keeps the practice alive. We don’t need to be a monk. This is a utility habit, not a personality trait.

What about projects with unknowns stacked three-deep?

We can still draw. In this case we label frames with questions and tests instead of tasks:

Frame 1: “What is the user’s #1 confusion?” 15-min call x 2 users.
Frame 2: “Which of 3 messages resonates?” 3 subject lines, 60-min test.
Frame 3: “Which tool integrates cleanly?” 1-hour spike in Zapier and Make. We are not drawing answers; we are drawing experiments. The form holds.

Check yourself: are you over-scoping the slice?

A fixed way to ruin this habit is to select a slice too large (e.g., “Ship the product”). The cure is to add a verb and a constraint. “Draft welcome email (150 words),” “Set up one data event,” “Install the shelf (120 cm).” The narrower the slice, the more likely nine frames capture it without fantasy. We then chain slices across days via the Brali task list.

Building the habit itself: a tiny container

We keep a cheap folder labeled “storyboards,” with dates on the top. It holds 10–20 pages. When it fills, we review and toss older ones. The keeping is not for posterity; it is to remind us that we do this often and quickly. If we go digital-only, we create a Brali tag “storyboard” and filter by it on Fridays.

If we want a ritual, we can decide: storyboard before email each morning. Keep the pen on the keyboard. When we open the laptop, we storyboard first, for 15 minutes. Then we open Slack. The brain learns: we see pictures before reading in. We keep a small mechanical pencil for the tactile cue.

Catching the tendency to chase breadth

Some of us will want to map everything once we start. It is seductive to draw the entire product, every page, every state. We resist. Instead, we define a “thin slice” we can build that yields learning or value. We storyboard that. After we finish tasks for that slice, we draw the next. Two or three storyboards chain into a body of work—without ever needing a huge speculative map.

Repairing a broken storyboard

If halfway through the day we realize our storyboard is wrong—e.g., we drew a MailChimp integration but the team uses ConvertKit—we do not edit the frame twenty times. We cross it out with a single line and draw a new frame below with the correct tool. We annotate the same labels. The strike-through is good history; the new frame is the fix. We put a date next to the new frame if it affects schedule.

Our policy on numbers: be literal

We have asked you to write minutes, grams, screw counts. This is not decoration. Numbers change action. If we guess too optimistically and learn we’re off by 50%, we write that down in the weekly check-in. Then we add a buffer next time. Tiny forecasting improvements are compounding. Over a month, they will save us hours and arguments.

Integrate Check-ins: a brief practice prompt

At the end of the day, inside Brali, we run a compact check-in:

“Did we sketch 3–9 frames today?” Yes/No
“Which frame became a task?” Type a short label (e.g., “Frame 8: Slack alert”)
“What did the storyboard help us avoid?” One sentence.

On Fridays, a slightly longer one:

“How many frames did we sketch this week?”
“Which risk label occurred most often?”
“Where did estimates exceed or lag by >50%?”

We pull the one largest estimation error and decide a small process fix: tool checklist, copy template, a saved Zap. The storyboard is not sacred; it is useful.

What not to do

Do not storyboard and never open a tool. Drawings are a means; the output is work.
Do not beautify for social sharing. It turns a private tool into a performance.
Do not argue in text when a 3-frame drawing will align faster. Pause the thread, draw, attach.

A closing scene: the feeling of a day with rails

It’s 4:20 p.m. We have 40 minutes before we have to leave. We look at our storyboard. Frames 3 and 8 are converted and complete. Frame 6—the welcome email—still stares at us with “20 min (MailChimp), risk: tone.” Twenty minutes is perfect for this slot. We open the template, write a short, plain email. We use the phrase that we circled on frame 4 earlier—“You’re in”—to keep tone aligned. We hit send on a test. Slack pings. We close the laptop with a kind of quiet satisfaction that doesn’t come from checking a box but from seeing the picture and walking it.

Tomorrow we will draw six frames for the onboarding sequence. Fifteen minutes. A pen. A page. A picture that tells us what to do next. It is humble. It works.

Check-in Block

Daily (3 Qs)

Did we sketch at least 3 frames today?
Which frame did we convert into a task and move forward?
What sensation did we notice while sketching (e.g., relief, frustration, curiosity), and what did it point to?

Weekly (3 Qs)

How many total frames did we sketch this week, and on how many days?
Where did our time estimates differ by more than 50%? What pattern do we see?
Which risk label repeated most, and what one-time fix can reduce it next week?

Metrics

Count: number of frames sketched per day
Minutes: total minutes spent visualizing per day

Busy-Day Alternative Path (≤5 minutes)

Draw 3 frames (start, critical action, end), 90 seconds total.
Label each with time, tool, risk (90 seconds).
Create 1 task from the middle frame and attach the photo in Brali (2 minutes). Stop. Execute the task. This preserves the habit and moves the project.

Mini-App Nudge (repeat)

If momentum dips, enable a 5 p.m. Brali notification: “Add 1 photo or 3-frame sketch to your Project Storyboard.” One tap to attach keeps streaks without pressure.

Closing reminder

Hack #80