Figma Page Organization Mistakes That Cost Teams Hours Every Week, and the Structure That Fixes Them

    November 18, 2026
    9 min read
    By Callan Whitmore
    Share this article

    A frontend developer opens the checkout file on a Tuesday morning to build the new address form. The pages panel shows 23 entries: "Checkout", "Checkout NEW", "Checkout final", "Checkout final v2 (use this)", "Sandbox Anna", "Old", "Old 2" and a dozen more. He picks "final v2", builds the form, and on Thursday the designer asks why the validation states are from the March version. Two days of work go back to the start. Nobody made a design mistake; the file did.

    Page structure in Figma looks like housekeeping, and teams treat it that way until the cost shows up in a sprint review. Below: the vocabulary, the mistakes that waste the most time, three page structures, a cleanup procedure and an illustrative before and after.

    Files, pages, sections and frames: drawing the lines

    Most organization problems start with using one level of the hierarchy for a job that belongs to another. Four terms are worth pinning down before any restructuring.

    File: the unit you share, version, branch and publish as a library. Permissions and version history work at file level, so a file should map to something a team owns, such as one product area or one platform.

    Page: a canvas inside a file. Pages are good for separating stages of work or major areas that the same people touch. They are bad as a versioning tool, which is how "final v2" pages appear.

    Section: a labelled region on a page that groups frames. Sections can be linked to directly and, in Dev Mode, marked as ready for development. That makes them the natural unit for handoff: one flow, one section, one status.

    Frame: a single screen, state or component. Frames carry the actual design and should be named after what they show, for example "Address form / error / postcode".

    A rough rule follows from these definitions. If two pieces of work have different owners or different release schedules, they belong in different files. If they belong to the same area but are at different stages, use pages. If they belong to the same flow, use sections on one page. And if they are versions of the same screen, they belong in version history or in a branch, not in duplicated pages.

    Most teams that follow the rule end up with five to nine pages per file. Files with more than about 15 pages usually hide a missing split into separate files, or a versioning habit that should move into history.

    The mistakes that cost the most time

    The expensive mistakes are not the ugly ones. A file with odd emoji in page names but a clear status per section is fine. The costly ones break the link between what is on the canvas and what is approved.

    • Versioning by duplicating pages. Every "v2" page forces readers to guess which is current. In the opening example, the guess cost two developer days, roughly 16 hours of rework.
    • No clear handoff location. If approved screens sit between explorations, developers search, and searching across 23 pages takes 10 to 15 minutes per visit. At 4 visits a day for a team of 5, that is around 4 hours a week.
    • Personal sandboxes in the shared file. They make the file heavier and mix unapproved ideas with real work. Drafts belong in personal drafts or a separate exploration file.
    • Components defined on product pages. When the same button lives in three places, a change happens in one and the other two drift. Fixing that later can take a full day of audit.
    • No archive. Teams either delete old work and lose context, or leave it in place and confuse everyone. Neither is necessary.
    • One giant file for the whole product. Load times grow, the memory warning appears and every designer is editing the same file at once.
    • Page names that describe people or dates, such as "Maria's work" or "Sprint 14". People move on and sprints end; the names stop meaning anything within a month.

    Three page structures and when each one fits

    There is no universal layout, but three structures cover most product teams. Choose one per file and stick to it.

    Structure A, by stage. Pages follow the life of the work: cover, explorations, in review, ready for development, shipped, archive. It suits a file that covers one product area worked on by two or three designers, where the question people most often ask is "is this approved?". The weakness appears when the area grows: the "ready for development" page fills with unrelated flows. Sections solve that up to a point, with one section per flow and a status on each.

    Structure B, by flow or feature. Pages are named after user journeys: cart, address, payment, confirmation, plus a cover, a components page and an archive. Status lives at section level. It suits bigger areas where several designers each own a journey. The risk is that the stage of work becomes invisible, so the team must be disciplined about marking sections as ready and moving explorations elsewhere.

    Structure C, by platform. Pages for iOS, Android and web versions of the same area, used when platforms ship on different schedules or when platform teams are separate. If platform teams are fully independent, consider separate files instead, since they will want separate permissions and branching.

    Whatever the structure, three pages appear in every file. A cover page with the file's owner, purpose and status, set as the thumbnail so the file is recognisable in the browser. A "start here" or readme frame that explains the page layout in two or three sentences. And an archive page at the bottom, where retired work goes with a date in the section name instead of being deleted.

    Cleaning up an existing file, step by step

    A messy file can be restructured in one afternoon without losing anything. Tell the team before you start, and do it on a quiet day.

    1. Save a named version in version history, for example "Before cleanup, 9 Nov". This is your undo button for the whole operation.
    2. List every page and write next to it what it really contains: approved work, exploration, old version, personal sandbox or components.
    3. Pick one of the three structures above and write the new page list. Aim for five to nine pages.
    4. Create the new pages and move content into them. Use sections for each flow, and name sections after the journey and the state, not after the designer.
    5. Move old versions and dead explorations to the archive page, each inside a section labelled with the month it was retired.
    6. Move components to a components page or, if other files use them, to the library file, and replace local copies with instances.
    7. Mark approved sections as ready for development, delete the empty pages, and send developers direct links to the handoff sections instead of a link to the file.

    After the cleanup, add a short rule to the readme frame: new versions go into version history or a branch, never into a new page. That single rule prevents most of the drift from returning. Then book a 15 minute check every month: open the pages panel, move anything stale to the archive and confirm that every section marked ready still matches what is in development.

    An illustrative mini-case: one checkout file, before and after

    This example is illustrative. A checkout team of three designers and five developers had one Figma file with 23 pages, built up over 14 months. The team estimated that developers spent around 5 hours a week between them looking for the right screens, and that roughly one ticket per sprint was built from an outdated frame.

    They chose structure B: cover, cart, address, payment, confirmation, components, archive. Seven pages. Each journey page had sections for every state, with status set at section level. Fourteen old pages collapsed into the archive, grouped into nine dated sections. Personal sandboxes moved into each designer's drafts. The components page shrank from 61 local components to 18, since most were duplicates of library items.

    The cleanup took one designer about 5 hours. Over the next two sprints, the team logged no tickets built from outdated frames, and developers reported finding handoff screens in under a minute through section links. The file also opened noticeably faster after the duplicate components and sandboxes left. Not everything improved.

    Two designers found structure B slower for quick explorations, because a new idea now needed a home in the right journey page or a separate exploration file. The team accepted that cost, since explorations were the work that most often confused developers in the old file. The team's other complaint was that the archive grew fast; they agreed to move anything older than 6 months into a separate archive file each quarter, linked from the cover page so the history stays one click away.

    Questions designers ask about organizing Figma pages

    Is there a limit on how many pages a Figma file can have? Paid plans do not set a practical page cap, but every page adds to the file's memory use. Figma shows a memory warning as a file grows, and heavy pages with many images or variants are what usually trigger it. Splitting by product area keeps files fast.

    Should the component library live in the same file as product screens? For a single small product it can, on its own page. Once two or more product files use the same components, move them to a dedicated library file, because publishing and versioning work at the file level, not the page level.

    How do I keep work in progress components out of the published library? Start the component name with a period or an underscore. Figma does not publish components named that way, so you can keep drafts next to stable components without other files picking them up.

    Do developers need access to every page? Usually not. Give them a link to the handoff page or to a specific section marked ready for development. Deep links to sections cut search time and stop developers from building from an exploration page by mistake.

    The trade-off, in the end, is between flexibility and findability. A loose file lets every designer work the way they like and costs the developers, the reviewers and your future self. A strict structure costs a few minutes of discipline per day and an afternoon of cleanup every few months. For a solo designer on a short project, loose is fine. For any file that more than three people open each week, the strict version pays for itself within the first sprint.

    Related Articles