Back to Explore
GuideVibeFix editorialUpdated Nov 17, 2026

Give New Users Something to Play With: Sample Workspaces and First-Run Activation for Your Vibe Project

Pumpkin List had 1,000 sign-ups and only 168 people reached their aha moment within 10 minutes. The problem wasn't missing features — new users stared at a blank page with no idea where to start. A sample workspace fixes that: a complete, realistic set of content they can change or clear. The project, people, and numbers in this guide are fictional examples.

A real photo: a woman laughing at an open laptop in a sunlit room, like someone who just started using a tool that clicks.

Don't Make New Users Stare at a Blank Page

Anan built a to-do list app called Pumpkin List. The idea was simple: open it, write things down, and sort out what to do first today. Three months after launch, the app worked fine, but new users didn't stick around. He checked the backend: a new user who signed up saw a clean, empty page with a single line on it — "No tasks yet. Click to create one." Most people glanced at it and left without creating a single task. At first Anan thought the app needed more features, so he added tags, reminders, and a calendar view. Retention didn't move. Then he talked to a few people who had signed up and left, and the answer was surprisingly consistent: it wasn't a lack of features, it was not knowing where to start. The blank page was so clean that nobody knew what the first line should be.

The numbers make it clearer. Last month Pumpkin List had 1,000 sign-ups. Of those, 860 people saw the sample workspace — the ready-made set of tasks that opens right after sign-up. Of the 860, 602 opened at least one sample task. Of the people who opened one, 301 edited or completed one. And in the end, 168 people reached their aha moment within 10 minutes of signing up: they put one of their own tasks into the list and actually used it to plan their day. In other words, out of every 100 people who signed up, fewer than 17 understood within 10 minutes what the product could do for them. The other 83 didn't dislike to-do lists — they left before they had a chance to like this one. A blank page isn't neutral. The blank page itself is a barrier.

One thing up front: the author, the product, and every number in this guide are fictional examples. The methods themselves are real, usable practices. Treat the numbers as worked examples for doing the math, not as industry data to quote.

A real photo: a woman laughing at an open laptop in a sunlit room, like someone who just started using a tool that clicks

First, Tell Three Things Apart: Samples, Templates, and Empty States

People mix these three up, and then none of them works well. An empty state is the line a product shows when there is nothing in it yet, like "No tasks yet. Click to create one." It only fits one kind of person: someone who already knows what they want to do and just needs a place to write it down. For a first-time visitor who doesn't yet know what the thing can do for them, an empty state is the same as leaving them standing at the door. A template is a half-finished skeleton, like a "Moving Checklist Template" or a "Back-to-School Template": the user picks one and fills in their own details. It fits people with a clear goal, but picking a template is itself a question the user has to answer: they have to figure out which situation they are in, then choose among seven or eight templates, and start over if they pick the wrong one. A sample workspace is different: the product already contains a complete, realistic set of things the user can change. No choosing, no filling in — they look, tap, and edit, and by editing they figure out what the thing is for.

Which one to use depends on whether the user knows what they want to do the first time they arrive. If they don't — if they only have a vague feeling like "I think I need something to keep track of things" — give them a sample workspace: let them play first, and let them get to their own stuff once they understand it. If they roughly know — "I'm moving, I need a list" — give them a template: the skeleton is ready, they just fill it in. If they already know the product well — an old user who just cleared all their tasks — one line of empty-state copy is enough, no need to teach them again. There is also a simple test: is your product the kind of thing people understand at a glance? If yes, you don't need samples. If not, or if most first-time users are likely to be confused, put the sample front and center — not hidden in settings, in a help doc, or behind a small grey link.

A quick boundary note, so you don't re-read what this site already covers. There is a guide on new-user onboarding design, about how to arrange a guided tour. There is a guide on the first-use path, about how to define the aha moment — importing data is just one of the three routes it mentions. There is a guide on building a template gallery, about how to make and organize templates. And there is a guide on test data and seed libraries, about fake data developers use for themselves — not data shown to users. This guide covers one thing only: how to build a user-facing sample workspace, what it should look like, and how to measure whether it works. No tour flows, no template library, no developer-side test data.

What a Good Sample Workspace Looks Like: Five Hard Rules

Rule one: it has to be real. Every line in the sample has to read like something a real person wrote. Tasks can't be called "Test Task 1" or "Sample content", dates can't all be the same day, and names can't be a lazy "John, Jane, Joe". Pumpkin List's sample workspace is a project called "Moving next week", with 12 tasks in three groups: contact the landlord, pack up, and things to do once you're in the new place. The tasks say things like "Pick up the new access card from the property office at 3pm Wednesday" and "Label the boxes by books, move the three heaviest boxes first". They have dates, priorities, and notes, and they read like a neighbour who is genuinely moving. A user looks at it and thinks: right, this is how it works — my move could look like this too.

Rule two: it has to be complete. A sample has to tell a whole story, not three lonely sentences. A few scattered tasks don't explain anything; after reading them the user still doesn't know whether the product can hold their day. Complete means there is a clear theme, a beginning, a middle, and an end — and some tasks already done alongside some still to do. The finished tasks matter: the moment a user opens the sample they can see what a checked-off task looks like and watch the progress bar move forward a notch, without having to do anything first. In Pumpkin List's sample, 4 of the 12 tasks are already checked off and progress shows one third done, so users see what "done" looks like before they do it themselves.

Rule three: it has to be changeable. A sample is not a museum piece — it's something users are meant to touch. Tap a task to rename it, tick it to complete it, drag it to reorder it, and get feedback right away: the numbers change, the progress bar moves, the page says "Nice, that's one down". Editing has to cost almost nothing: no second account to register, no tutorial to watch, no "enter edit mode" button to find first. If changing one sample task takes three confirmations, it's not a sample, it's a checkpoint. One small detail helps: the first edit deserves a small piece of positive feedback, like a "First one done" note when the user completes their first task, so they know the thing they just did was right.

Rule four: it has to be deletable — and easy to delete. A sample is lent to the user for practice, not left in the product like clutter. There should be a visible "Clear the sample" button: one tap, the sample is gone, and the user's space is clean. One confirmation is enough; don't scare people with repeated warnings. After clearing, leave a way back, like "Sample cleared — you can add a fresh set any time". The worst failure is a sample that doesn't delete cleanly: the tasks are gone but the tags remain, the project is gone but the reminders keep firing. A fake task sitting next to the user's first real task is worse than no sample at all.

Rule five: it must not steal the show. The sample is a supporting actor; the user's own stuff is the lead. The moment someone arrives, they should see two things at once: what this sample is about, and where to start with their own stuff. In Pumpkin List, there is always a "Create my first task" entry next to the sample project, and every sample task carries a hint like "Make this one yours". No matter how good the sample tasks are, the user should never feel like this product belongs to someone else. Sample tasks are there to be copied and changed, not admired.

Four Steps in 10 Minutes: From Sign-Up to the Aha Moment

Split the 10 minutes after sign-up into four steps. Each step has a number, and each has a concrete fix. Step one, sign-up to seeing the sample: 1,000 people signed up, 860 saw the sample workspace, and 140 were lost. Most of the 140 were pulled away by a detour: a "Complete your profile" form popped up right after sign-up, or the page jumped to "Pick a plan" first. The fix is one sentence: the first screen after sign-up is the sample workspace. Forms, plans, and "Pick three tags you're interested in" all come later. The user came to try the product, not to fill in a form.

Step two, seeing the sample to opening a task: 860 people saw it, 602 opened at least one task, and 258 were lost. People are usually lost here because the sample looks like an ad: a heading that says "Welcome to Pumpkin List" and a task that says "Click here to try it out". Users can tell real content from decoration. The fix is to make the first sample task something people want to tap: a concrete thing, not a slogan. "Pick up the new access card from the property office at 3pm Wednesday" is ten times stronger than "Try clicking to complete a task" — the first is life, the second is a manual. Another trick: put the most vivid task at the top, so the first thing a user sees has a picture in it.

Step three, opening to editing: 602 people opened a task, 301 edited or completed one, and 301 were lost. This is the step that loses the most people, and the one most worth fixing. People who opened a task are already interested; when they don't edit, it's usually because they don't dare to — they're afraid of breaking it, of not being able to undo it, of dirtying the sample. The fix is to say out loud that it's fine to mess around: a line next to the task like "Tap to edit — anything can be undone", plus a "Restore the sample" way back. People only dare to touch things when they know they can take it back. Pumpkin List also made one small change: when you first open a task, the input box isn't empty — it already contains the original text, so the user only has to change a few words. Turning "write a new line" into "change a few words" drops the barrier to almost nothing.

Step four, editing to the aha moment: 301 people edited something, and 168 reached their aha moment within 10 minutes — 133 were lost. The key here is to define the aha moment clearly first. For Pumpkin List, the aha moment isn't "edited a sample task". It's "put one of my own things into the list and used it to plan my day". Editing a sample is practice; the moment your own stuff shows up, it counts. So the fix for step four is to build a bridge: right after the user edits a sample task, the page asks, "Want to add the one thing you most want to do today?" The input box is already open and the cursor is already blinking — the user just types a few words and hits Enter, and the whole journey is done. When the bridge is there, an edit turns into their own task; when it isn't, the user edits a sample, thinks "that was fun", and leaves.

Sample workspace activation funnel: 1,000 sign-ups, through seeing the sample, opening a task, and editing a task, to 168 people reaching their aha moment within 10 minutes

Three Kinds of Sample Content — Don't Pick the Wrong One

The same sample can perform very differently depending on what it's made of. Count it per 100 people who saw the sample workspace. The first kind is placeholder copy: tasks that say "Sample Task 1" or "Lorem ipsum dolor sit amet". Open rate is 22%, edit rate is 5%. Users aren't foolish — they can spot fake copy at a glance, and once they spot it they stop going deeper. If you don't take your own content seriously, why should they? The second kind is three thin tasks: three real tasks, but only three, and they don't add up to a story. Open rate is 41%, edit rate is 12%. Better than placeholder copy, but users still can't tell whether the product can hold their whole day — three tasks aren't enough to make something feel like a workspace. The third kind is a complete, realistic project: like Pumpkin List's "Moving next week", 12 tasks, three states, some done, some to do. Open rate is 70%, edit rate is 35%. Note that the 35% is counted against everyone who saw the sample; among the people who opened a task, that's one in two — half of the people who opened something actually changed it.

The conclusion is blunt: the cost of a sample isn't in writing a few lines, it's in making it feel real. Writing a complete, realistic sample takes five or six times as long as writing three fake tasks, but the open rate and edit rate more than double. One more point that's easy to miss: write the sample around the scenario your product is best at. A to-do list should show a move, a first week at school, or a trip — not "the company's quarterly plan", which is far from your users' lives. What users see in the sample should be their own next week, not someone else's annual meeting.

Three sample content types compared: placeholder copy, three thin tasks, and a complete realistic project, on open rate and edit rate

Three Red Lines for Sample Data

Red line one: never use real users' data as your sample. Not "anonymized" data, not "nobody would recognize it" data — none of it. A sample sits in front of every new user, and real user data mixed into it is a leak waiting to happen. The right approach is to invent it: invent a person, invent a scenario, invent a set of tasks, and make it feel real while all of it is made up. Red line two: don't use the names of real people, companies, or places in the sample. Don't make your sample's hero a friend you know, and don't use a real company's name as the sample's client. Invent an "Anan", invent a "Moving next week" — that's enough. Red line three: label the sample as a sample. A small line in the corner of the workspace — "This is sample data, you can clear it any time" — tells the user "this isn't yours, go ahead and change it", and it also covers you: these words were written by me, they aren't real.

These three lines look like small print, but they decide whether a sample can stay around for the long term. A sample isn't a one-off decoration; every new user will see it. If the data source isn't clean, if real people's names are in it, and if nothing says it's an example, sooner or later someone will ask "Who is the person in this task?" By then, fixing it means changing the first thing every new user sees, which costs far more than inventing it cleanly in the first place.

A 30-Minute Checklist Before You Ship

Before the sample workspace goes live, spend 30 minutes on this list. One: the first screen after sign-up is the sample — no clicking, no searching, no form to fill in first. Two: every line in the sample reads like a real person wrote it — no Lorem, no "Test Task". Three: the sample tells one complete story, with some tasks done and some still to do. Four: one tap edits it, the edit gives feedback right away, and a mistake can be undone. Five: there is a visible "Clear the sample" button, and clearing leaves no leftovers. Six: the "Start with my own stuff" entry is always next to the sample. Seven: the sample contains no real user data, no real people's or companies' names, and a corner note says "This is sample data". Eight: find someone who has never used your product, let them sign up and play for 10 minutes, then ask them one question: "What do you think this product helps you do?" If they can answer, the sample passes. If they can't, go back and fix the sample — don't rush to add features.

After launch, watch just three numbers each week: how many sign-ups saw the sample, how many of those opened a task, and how many reached their aha moment within 10 minutes. Whichever number drops hardest tells you which step to fix first. Few people seeing it — fix the first screen. Few opening — rewrite the first task. Few editing — make "go ahead, it can be undone" clearer. Few reaching the aha moment — build the "add one of your own things" bridge more smoothly. A sample workspace isn't something you ship and forget; it's the first thing new users see of you, and it's worth a look every week.

In the end, a sample workspace does one small thing: it lets a new user feel what the product is like to use before they have to do any work. A blank page makes people freeze, a template makes people choose, and a sample lets people get their hands on it right away. Users aren't talked into it in 10 minutes — they talk themselves into it, by editing a task, finishing something, and putting one of their own things into the list. Your job is just to pave those 10 minutes flat.

Views 8Comments 0

Comments (0)

ME
0/1000
Loading comments...
Browse projectsPublish your project

Related articles

Real photo: a bank of light gray metal filing cabinets with one drawer pulled open, revealing rows of hanging file folders inside
Guide
A real database inside the browser: IndexedDB local storage, explained plainly

localStorage only stores strings and has no indexes. IndexedDB is a real database in the browser: structured data, far larger capacity, indexes, and transactions. Following MDN's Using IndexedDB, IDBDatabase, and IDBObjectStore: the five-step routine, opening, upgrades, keys, indexes, transactions, add versus put, get, cursors, ranges, and multi-tab upgrades.

Tool TipsData WorkflowsFrontend Engineering
Real photo: hands typing on a MacBook Pro showing JavaScript code that changes HTML content, with a white mouse, papers, and binders on a white desk
Guide
Functions without the confusion: JavaScript functions, parameters, and arrow functions, explained plainly

You already call functions every day; this guide names what you have been doing. Following MDN's Functions, Arrow function expressions, and Rest parameters: declarations versus expressions, parameters and arguments, default values, rest parameters, spread syntax, return values, arrow function shorthand, the this trap, callbacks, and scope.

Tool TipsFrontend EngineeringAI Coding
Real photo: a laptop, tablet, and phone on a wooden table showing the same green-leaf website, the phone view with navigation in one column, a potted plant nearby
Guide
Squashed on phones? Responsive layout and media queries, explained plainly

One page should stand up on a phone, a tablet, and a computer. This guide follows MDN's Responsive web design, Using media queries, and the viewport meta reference: fluid HTML, the viewport tag, fluid grids and max-width, images that never burst their container, media query syntax, breakpoints set by content, mobile first, responsive type, testing capability instead of width, and a pre-launch checklist.

Mobile AppsDesign ExperienceFrontend Engineering