Before a developer writes a single line of working code for a new app, website or business system, you are usually shown a set of screens: a wireframe, a mock-up, or a clickable prototype that lets you tap through a chosen path. This is normal, and it is also the cheapest point in the whole project to catch a mistake. A screen changed before the build starts might cost nothing more than redrawing it. The same change, found after the system is built, usually means rebuilding working code, which costs real time and money. This guide is for a non-technical owner who has been sent a design-tool link, a PDF of screens, or an in-person walkthrough, and is not sure what to actually check, how deep to go, or what approving the screens commits them to.
Wireframe, mock-up or clickable prototype: what you are actually looking at
These three terms get used loosely, and the difference matters for what you should be judging:
- Wireframe. A plain, mostly black-and-white layout showing where things sit on a screen: a box for a heading, a box for a list, a button where an action goes. There is no real colour, imagery or finished wording. Its only job is to show structure.
- Mock-up. A wireframe with visual design added: colours, fonts, spacing and real or placeholder images. It usually looks close to the finished screen, but it is normally still a static picture, not something you can click through.
- Clickable prototype. Several screens linked together so you can tap or click through a chosen path, such as placing an order or approving a leave request, without any of it being working software. It behaves like the real thing along that one path, and nowhere else.
A useful habit, borrowed from how design teams run this stage: keep wireframe-level review about structure and flow, not colour or wording, and leave visual comments for the mock-up stage. Mixing the two slows the review down and can bury a real structural problem under a debate about a shade of green.
Why this review matters more than it looks
A screen is cheap to change. A line of working code that depends on that screen is not. Once a developer has built the database, the logic and the connections behind a screen, reworking its structure usually means reworking code that already works, which is slower and more error-prone than redrawing a picture. This is why most development approaches put real weight on getting the screens right before building starts, even though it can feel like an extra step when you just want the system finished.
That does not mean this stage decides everything. A prototype still cannot prove the finished system will work, which is covered further down. But it is the stage where a missing screen, a confusing order of steps, or a task nobody thought to include is cheapest to fix, which is exactly why it deserves a proper look rather than a quick nod.
How to review: walk your own real work through the screens
Do not simply look at each screen and say it looks fine. Walk your own actual work through it instead:
- Pick two or three real tasks you or your staff do today, using real examples: an actual order, an actual leave request, an actual customer enquiry, not a generic made-up one.
- Follow each task screen by screen, in the order you would really do it, and ask at every step: is the information I need here, is it in the order I need it, and does this button do what I expect?
- Bring the people who will actually use it. An owner reviewing alone can miss what a cashier, a technician or an office admin would catch in seconds. If a developer can join the same session, feedback on structure and feedback on requirements arrive together instead of in separate rounds.
- Say what you see, not just what you feel. “I don’t know where to find today’s orders’ is more useful to a developer than “this feels off”.
This is slower than clicking through once and approving it, and that is the point: an hour spent here is far cheaper than the same gap found after the build starts.

What is easy to miss when you review a prototype
Most reviews cover the main, happy-path screen well and quietly skip everything around it. The gaps below are where a missed requirement usually hides:
| What to check | Why it is easy to miss | What to ask | |
|---|---|---|
| Error and warning screens | Reviewers click the path that works, not the one that fails | What does this screen show if the input is wrong, or the action fails? | |
| Empty states | A prototype is usually shown with sample data already filled in | What does this screen look like on day one, before any data exists? | |
| Who sees what | One reviewer usually only sees one role’s screens | What does a staff account see here that an owner account does not, and the reverse? | |
| The rare case | It is easy to design only for the common, everyday case | What happens for the case that only comes up once or twice a month? | |
| Reports and exports | A short demo list looks fine; years of real records may not | How does this report or export look with a realistic amount of data? | |
| Phone-sized screens | Reviews often happen on a wide monitor, not the device staff will actually use | Does every screen still work, and look right, at phone width? | |
A one-page review sheet you can copy
Keep your review on one sheet, screen by screen, rather than scattered across memory and chat messages. This made-up example, for an illustrative handyman booking system, shows the shape:
| Screen | Task it supports | What’s missing or wrong | Priority | |
|---|---|---|---|
| New booking form | Customer requests a repair | No field for preferred time window | Must | |
| Technician schedule | Assigning jobs for the day | No way to see a technician who is on leave | Must | |
| Job history (empty) | A brand-new customer’s first visit | Screen was only shown with sample history filled in | Should | |
| Monthly report | Owner checking completed jobs | Unclear how it reads with a full year of jobs | Later | |
“Must” items block sign-off. “Should” items are worth fixing now if they are quick. “Later” items go on the change list covered below, not into an argument about this round.
Giving feedback as one list, not scattered messages
Feedback that arrives as a voice note, a WhatsApp message the next day, and a verbal aside in a meeting is hard for a developer to act on, and easy for half of it to get lost. Before you send anything, consolidate your review sheet into one list, organised by screen, and send it as a single round. If a second person also reviewed, merge both sets of comments first rather than sending two separate lists that may contradict each other.
What ‘approved’ should mean, in writing
Before you approve anything, agree in writing what approval actually does. The usual, sensible meaning is that the approved screens become the project’s scope: the set of tasks, screens and rules the build will follow. It does not need to mean every pixel is final, and it does not mean the owner has signed away the right to ever change anything.
- Scope is what gets built. Once approved, the screens are what the quote and the schedule are based on. Reopening a structural decision after this point is a change, not a correction, and how a quote is built is worth reading before you reach this stage, not after.
- Keep a separate change list. Anything you want added or altered after approval goes on a running list, priced and scheduled deliberately rather than slipped in as a “small thing”. A weekly check-in routine is a natural place to log and review that list.
- Ask how pricing responds to this stage. Whether changes after sign-off are billed by the hour, by a fixed change price, or absorbed up to a limit depends on how the project is priced. Fixed price or hourly rate explains what each model does to a late change.
- Put the sign-off itself in writing, even if it is a short email: which screens, which version, and the date. A verbal “looks good, go ahead” is easy to misremember once a dispute comes up.
The limits of a prototype — what it does not test
A clickable prototype is good at showing structure and flow, and poor at proving the system will actually work once it is real. Knowing the difference stops you from signing off thinking more has been checked than actually has:
| What a prototype shows | What it does not test | |
|---|---|
| The screens and your chosen click-through path | Real data, at a realistic volume | |
| The general look and the order of steps | How the system actually stores, calculates or protects data behind the screen | |
| The one path you were shown | Every edge case and error condition | |
| A handful of linked screens | Speed under real, everyday use | |
| What you personally clicked through | Whether other systems it must connect to actually work with it | |
Those checks belong to a later stage, once real software exists: see how to test a custom business system before you accept it for what that stage should cover. Approving a prototype is not the same as accepting the finished system, and no one should treat it that way.
How many review rounds to agree on upfront
There is no universal rule for how many rounds of screen review are reasonable, so agree a number before reviewing begins rather than discovering it mid-project. Two or three rounds, each ending with a clear “must fix” versus “later” list, is a common and workable shape. What causes real delay is not a second round, but an open-ended cycle where the same screens are revisited indefinitely without anyone saying when review ends and building begins.
- Agree the number of rounds, and what happens if you genuinely need one more.
- End every round with a written list, not a verbal “mostly fine”.
- Separate “this is wrong” from “this would be nice” in that list, so the must-fix items are not lost among preferences.
- Set a date for final sign-off, and treat it as the point the change list (above) takes over from free revision.
Common mistakes
- Only clicking the happy path. Approving a prototype after one smooth run-through, without checking error, empty or edge-case screens.
- Reviewing colour and wording at wireframe stage. It distracts from checking whether the structure actually supports the work, and gets redone anyway once visual design is added.
- Reviewing alone. The owner approves screens the actual day-to-day users never see until the system is live and something is already wrong.
- Sending feedback as it occurs to you. A drip of messages over several days is harder to act on than one consolidated list.
- No agreed number of review rounds. Without one, review can continue indefinitely and the build never starts.
- Treating approval as informal. A verbal “looks fine” with nothing written down leaves no record of what was actually agreed.
- Assuming the prototype proves the system will work. It shows screens and a path, not real data, speed, or connections to other systems.
- Letting every afterthought back into this round. A late idea that is not essential belongs on the change list, not in a delay to sign-off.
Where Gotka Technologies fits
Gotka’s App & System Development service builds mobile apps, web apps and business systems, with indicative prices from RM8,000 for web apps and dashboards, RM12,000 for business systems and integrations, and RM15,000 for mobile apps, confirmed by a written quote. This guide is general advice for any owner reviewing screens from any builder. It does not describe a specific Gotka design process, a set number of review rounds, or a particular deliverable, because none of that is published in the material it can cite. Ask any builder, Gotka included, to confirm in writing how many review rounds are included and what happens afterwards. If you are scoping a new project, get in touch.
Key terms used in this guide
- Wireframe: a plain layout showing where things sit on a screen, with no real colour or imagery.
- Mock-up: a wireframe with visual design added, usually still a static picture.
- Clickable prototype: linked screens you can tap or click through along a chosen path, without working software behind them.
- Scope: the set of tasks, screens and rules the build is based on, usually fixed once screens are approved.
- Change request: anything added or altered after scope is agreed, priced and scheduled separately.
- Happy path: the one smooth sequence of steps where nothing goes wrong.
- Edge case: an unusual situation outside the everyday, common one.
- Empty state: what a screen looks like before any real data exists in it.
- Sign-off: a written record that specific screens, at a specific version, were approved on a specific date.
- User acceptance testing (UAT): testing the finished, working system against real tasks, a later stage than reviewing a prototype.
What is the difference between a wireframe, a mock-up and a clickable prototype?
A wireframe is a plain, mostly black-and-white layout showing where things sit on a screen, with no real colour or imagery. A mock-up adds visual design, such as colours, fonts and real or placeholder images, but is usually still a static picture. A clickable prototype links several screens together so you can tap or click through a chosen path, such as placing an order, without any of it being working software yet.
How should I review a prototype or screen designs before a build starts?
Walk your own real daily work through the screens rather than just looking at them. Pick two or three actual tasks you do today, with real examples, and follow each one screen by screen, asking whether the information you need is there, in the order you need it, and whether every button does what you expect, before you approve anything.
What is easy to miss when reviewing a prototype?
Reviewers usually check the main, happy-path screen and skip the rest. Commonly missed screens are error messages, empty states before any data exists, who is allowed to see or do what, the unusual case that happens only once or twice a month, how reports and exports look with a realistic amount of data, and how every screen behaves at phone width, not just on a wide monitor.
What should ‘approved’ mean when I sign off on a prototype?
Agree in writing, before you approve anything, that the approved screens become the project’s scope: what the system will do and roughly how it will look, not a final guarantee of every pixel. Keep a separate running list for anything you want added or changed after approval, so new requests are priced and scheduled deliberately instead of quietly expanding the original build.
Can a prototype tell me whether the finished system will actually work?
No. A clickable prototype only shows the screens and the paths you click through; it does not use real data, is not connected to any other system, and says nothing about how fast the finished build will run under real use. Those need separate checks, usually covered by acceptance testing once real software exists, not by reviewing screens.
How many rounds of prototype review should I agree to before the build starts?
There is no fixed rule, so agree a number with your developer before reviewing begins, commonly two or three rounds, each tied to a clear must-fix versus later list. Open-ended revisiting of the same screens is what usually causes delay, so settle how many rounds are included and what happens if you genuinely need one more.
What happens if I spot a problem after the build has already started?
Tell your developer straightaway rather than waiting for the next scheduled check-in, because a structural change found early in the build is far cheaper to fix than one found near the end. Expect it to be logged as a change rather than assumed to be free, and ask how it affects the agreed price and date before work on it continues.
Keeping a Custom Software Build on Track: A Weekly Check-In Routine for Non-Technical Owners
Custom software project check-in: what to ask for every week, a one-page template, warning signs of drift, and why late decisions and data slow builds.
App DevelopmentFreelancer, In-House Developer or Development Company: Who Should Build Your Business System?
Freelancer, in-house developer or development company? A decision guide to who should build your business system, what to ask each, and where each fits.
App DevelopmentWhat to Prepare Before Your First Conversation With a Software Developer
What to prepare before your first conversation with a software developer: the real pain point, the users, existing tools, real examples, budget and timeline.


