Blog / Design · 7 min read ·
Wireframing your capstone, from paper sketch to prototype
Build a screen inventory, sketch low-fidelity wireframes, move to high fidelity in Figma, and annotate screens so your team builds the same thing.
Wireframes are the cheapest place to make mistakes. Moving a button on paper takes seconds; moving it after three modules are coded can take a weekend. This guide walks your team from a screen inventory to annotated, high-fidelity screens you can show your adviser and test with users.
Why wireframe before you code
A wireframe is a simplified drawing of a screen that shows structure, content and actions without final colours or images. It answers three questions: what is on this screen, where does it go, and what happens when the user acts. For a capstone team, wireframes also do something more practical. They let your frontend and backend members agree on what data each screen needs before anyone writes a query.
- Your adviser can comment on flow and scope early, when changes are cheap.
- Stakeholders such as the registrar or the rural health unit nurse can point out missing steps in their real process.
- Wireframes double as figures for your design chapter.
- They expose scope creep: if you need 60 screens, you may have promised too much.
Start with a screen inventory
Before drawing anything, list every screen the system needs, grouped by user role. Derive the list from your objectives and use cases, not from imagination. The example below is a partial inventory for a barangay records and certificate request system.
| ID | Screen | User role | Purpose | Priority |
|---|---|---|---|---|
| S-01 | Login | All | Authenticate users by role | Must have |
| S-02 | Resident list | Secretary | Search, filter and open resident profiles | Must have |
| S-03 | Resident profile | Secretary | View and update household and personal details | Must have |
| S-04 | Certificate request form | Resident | Request a clearance, indigency or residency certificate | Must have |
| S-05 | Request queue | Secretary | Review, approve or reject pending requests | Must have |
| S-06 | Certificate preview and print | Secretary | Generate the printable certificate | Must have |
| S-07 | Reports dashboard | Punong barangay | View request counts and population summaries | Should have |
| S-08 | Audit log | Administrator | Review who changed which record and when | Should have |
The three levels of fidelity
Fidelity describes how close a wireframe looks and behaves to the finished system. Move through the levels in order, and do not skip straight to high fidelity: polished screens make people comment on colours instead of flow.
| Level | Tools | What it shows | Best for |
|---|---|---|---|
| Low | Paper, pen, whiteboard, sticky notes | Rough boxes, labels and arrows between screens | Exploring layouts quickly as a team |
| Mid | Figma free plan, draw.io (diagrams.net), Penpot | Real labels, field names, grey boxes, consistent spacing | Adviser review and agreeing on data per screen |
| High | Figma free plan or similar | Final typography, colours, real sample content, clickable links | Usability testing and defense presentation |
Free design tools change their plans and limits over time, so check what the current free tier includes before your team commits to one.
Low fidelity: paper first
Give each member a stack of paper and ten minutes per screen. Everyone sketches their own version of the same screen, then the team compares and combines the best parts. Draw boxes for content areas, write real labels instead of squiggles, and draw arrows to show where each button leads. Take photos and store them in your shared drive under the screen ID.
Mid fidelity: structure and real content
Recreate the chosen sketches digitally in greyscale. Use your actual field names, such as Purok, Household no. and Purpose of request, because these must match your database columns later. Set a simple grid and spacing so screens line up. This is the version to bring to your adviser and stakeholders.
High fidelity: looks and behaves like the system
Apply your type scale, colours and components, and link screens together into a clickable prototype. Fill the screens with realistic but fake sample data. Check colour contrast now, while changes are still cheap. The high-fidelity prototype is what you test with users before coding the remaining modules.
A sample wireframe, described
Here is a mid-fidelity wireframe for screen S-04, the certificate request form, described region by region. A table like this is useful when you cannot embed an image, and it is a good format for annotations in your manuscript.
| Region | Content | Behaviour |
|---|---|---|
| Header | Barangay name, back arrow, page title "Request a certificate" | Back arrow returns to the resident home screen without submitting |
| Step indicator | "Step 1 of 3: Certificate details" | Updates as the resident moves through steps |
| Certificate type | Radio list: Barangay clearance, Certificate of indigency, Certificate of residency | Required; selecting a type shows its requirements below |
| Purpose | Dropdown: Employment, Scholarship, Medical assistance, Other | Selecting Other reveals a short text field |
| Requirements note | Plain text listing what to bring on pickup | Content changes with the certificate type |
| Primary action | Full-width "Continue" button at the bottom | Disabled until required fields are complete |
| Error area | Inline messages under each field | Shown when a field is left invalid, with text and an icon, not colour alone |
Annotating your wireframes
An unannotated wireframe leaves too much to interpretation, and every developer on the team will interpret it differently. Annotations are short numbered notes placed beside the screen that explain what the drawing cannot.
- Data source: which table and columns fill this element, for example
residents.last_name. - Validation: rules such as required fields, formats and limits.
- States: what the screen shows when empty, loading, failed or successful.
- Permissions: which roles can see or use the element.
- Navigation: where each action leads, using screen IDs.
A workflow for your team
- 01
Build the screen inventory
List every screen by role from your use cases and assign screen IDs.
- 02
Sketch on paper
Everyone sketches the must-have screens, then the team merges the best ideas.
- 03
Create mid-fidelity screens
Recreate in greyscale with real labels and field names that match your planned database.
- 04
Review with adviser and stakeholders
Walk through each user flow and record the feedback against screen IDs.
- 05
Annotate and finalise
Add data sources, validation, states and permissions to each screen.
- 06
Build the high-fidelity prototype
Apply the visual design, link screens, and run a usability test before full development.
Keep the files in a shared location your adviser can open, and export key screens as images into your docs folder so they are versioned alongside the manuscript.
Next step
List every screen in your scope before your next team meeting, then sketch the three your main user needs most on paper. Check each sketch against the UI/UX basics before you build a prototype.