You built the prototype. You're proud of it. Then comes the part everyone skips: actually putting it in front of strangers and finding out it's confusing.

Skipping that step is expensive. A Nielsen Norman Group analysis found teams that don't do formal usability testing ship products far more likely to flop, and classic NN/g research shows you catch most of a prototype's biggest problems with just five testers. The catch has always been the overhead around those five testers: writing the script, recruiting the right people, taking clean notes, then drowning in a Google Doc of quotes you have to manually tag at midnight. Agencies charge five figures a round to handle that overhead. Solo founders just don't do it.

That overhead is exactly the part that's now optional.

You don't build the testing system. You describe it.

The old way to run shoestring testing in a tool like Dotallio was to build it yourself: create a board, add columns for participant, task, severity, quote, set up a feedback form, wire up the views. An hour of setup before you've talked to a single user.

The new Dotallio is chat-first. You describe the testing program you want in plain language, and Dotallio assembles it — the board, the columns, the sample rows, the form, the analysis. Everything it generates is a live, editable, version-controlled artifact you and a teammate can revisit, refine, and reuse for the next round. You don't configure it. You describe it, and it keeps the thing alive as feedback rolls in.

Here's what a real session looks like.

A real session, prompt by prompt

1. Spin up the whole testing program in one sentence

Open the chat and type what you're testing and who you're testing with:

Create a usability testing tracker for my new project-management app prototype. I'm testing with 5 solo founders. I need columns for participant name, user type, the task they tried, completed/struggled/failed, severity, a verbatim quote, and a category like "navigation / onboarding / checkout." Add 3 example rows so I can see the shape.

Dotallio builds the board for you: the right column types (a status column for completed/struggled/failed, a select for severity, a long-text column for the quote), a couple of useful views, and three sample rows so the structure is obvious before you fill it in. No manual column-by-column setup. If you want to tweak anything, you tell it — "make severity a 1-5 scale" — and it edits the board.

2. Get the script and the tasks as an editable doc

A board to hold results is half of it. You also need something to actually say to testers. Ask for it:

Write me a 5-minute moderated test script for this prototype: a warm intro, a think-aloud reminder, and 3 task scenarios that exercise onboarding, creating a project, and inviting a teammate. Then give me 4 rating-scale questions (1-5) and 3 open-ended questions about clarity.

Dotallio produces a rich doc artifact — your script, tasks, and question bank in one place. It's not a dead PDF. It's versioned: edit it after your first session when you realize a task is ambiguous, and the old version is still there if you want it back. Set it to a public link and hand it to a co-moderator, or keep it private to your workspace.

3. Recruit and screen with a form Dotallio builds

You need five of the right people, not five of your friends. Describe the screener:

Make an intake form for recruiting testers: name, email, their role, what tools they use today, and how often they manage projects. Only let through solo founders who use a PM tool weekly. Feed submissions into the testing tracker board.

Dotallio generates the form and links it to your board so every qualified sign-up lands as a row, ready to schedule. Share the link in a Slack community or on X, and your recruiting pipeline fills itself.

4. Drop in the mess and let it structure itself

This is the part that used to eat your weekend. After your sessions you have ten pages of raw notes, scattered quotes, and a couple of voice-memo transcripts. Paste the whole jumble into the chat:

Here are my raw notes from 5 testing sessions. Pull out each distinct usability issue, assign a category and a severity (High/Med/Low) based on how the user described it, count how many testers hit it, and add the best verbatim quote for each. Put it in the testing tracker. [paste notes]

Dotallio reads the mess and writes clean rows into your board — issue, category, severity, frequency, quote — using the columns you already defined. What was a multi-day tagging slog becomes a few minutes. You review and adjust; the AI did the sorting, you keep the judgment.

You can even @-mention another board — say a backlog you keep — so the chat has that context when it suggests which issues map to existing tickets.

Keeping it alive between rounds

A one-time analysis is nice. A program that improves with every round is the point.

• AI-filled columns keep new feedback consistent. Add a row from round two and let an AI column auto-suggest its category and severity using the same rubric as round one, so weeks of feedback stay comparable instead of drifting.
• Smart Workflows do the heavier lifting on demand. Trigger one with a button — "summarize all High-severity issues from this round and draft the action items" — and it plans the steps, reads the board, and writes the summary as an artifact. It can also run live web research to check how comparable apps solve a friction point you keep hearing about.
• Triggered enrichment means a workflow can fire when a new tester submits the form or when a row's status flips to "failed," routing that signal where it needs to go. (On-demand and event-triggered — you press the button or the board event fires it; nothing runs unattended overnight.)
• Versioned artifacts mean your script, your analysis doc, and your insight tables all carry history. Roll back a bad edit, compare round one to round three, and reuse last quarter's setup for next quarter's prototype without rebuilding it.

What this looks like in real life

Jamie is a solo founder testing a membership-site prototype with five users she found in a Discord. Friday afternoon she has the usual: ten pages of Google Docs notes, a few screenshots, and a sinking feeling that the important stuff is buried.

She opens Dotallio and types: "Create a usability tracker for these notes — issue, category, severity, frequency, quote — and fill it from this text." She pastes everything. In under half an hour she's looking at a sorted board, not a wall of prose. The pattern is obvious: four of five testers stalled on the checkout flow (High), three found the dashboard confusing (Med). She presses a workflow button to draft the action items as a doc, sets it to a workspace link, and sends it to her developer before the weekend. No agency. No research team. No lost feedback.

The next month, testing version two, she doesn't rebuild anything. She duplicates the artifact, points the chat at the new notes, and the same structure catches the new issues.

Why this is better

• No setup tax. You describe the tracker, script, and form in a sentence each — Dotallio builds them instead of you wiring columns and views by hand.
• Messy in, structured out. Paste raw notes, transcripts, even a photo of a whiteboard; vision OCR and AI structuring turn it into clean, comparable rows.
• It stays consistent. AI-filled columns and a shared rubric keep round three comparable to round one instead of drifting.
• It stays alive. Versioned, editable artifacts and triggered Smart Workflows mean your testing setup compounds across prototypes instead of being thrown away each round.
• Zero research budget required. Five testers and a chat box get you a prioritized, evidence-backed list — the same output an agency hands you, minus the invoice.

You don't need a big budget to test like a team that has one. You need to stop building the scaffolding by hand and start describing what you want.

Paste your last set of testing notes into the chat and watch it become a prioritized action plan in minutes. Try Dotallio Free.