Describe me the process of a handover Figma design to the development team. General…
- User
Describe me the process of a handover Figma design to the development team. General information: We will use two Figma project: one for product, one for development. Once the design is acceppted UXUI designer will copy the given scenario page to the Development figma project. Development figma project will have following 4 sections:
- prototype - showcasing the basic of interaction and flow. it will nevery be fully working design - just basic happy path. Prorotype will be the same version as used during Design Review meetings with stakeholders and therefore it can be not used as a specificaiton. Prototype is not mandatory
- all screens and variants - check for a consistance and including enough annotations giving development team more details about requirements, interactions, flows
- index of the links to context / supplementaty materials made as Confluence pages
- any items parked away for the future and not valid as a development goal
Consdier the process in context of:
- adding a new work orders to developers
- updating already passed over to developers tasks
- moving some scenario page from Figam shared file to individual file - for archive purpose and limiting the size of a growing design project
- Assistant
Below is a detailed description of the handover process for Figma designs to the development team, based on the general information you provided. I'll structure it as a step-by-step process, incorporating the two Figma projects (one for product/design and one for development). The Development Figma project serves as the "single source of truth" for developers, organized into the four specified sections:
- Prototype: A basic showcase of interactions and flow (happy path only; not fully functional). This mirrors what was presented in Design Review meetings with stakeholders, so it's not suitable as a formal specification. It's optional and not mandatory for handover.
- All Screens and Variants: A comprehensive collection of screens, including variants for different states (e.g., loading, error, success). This section ensures consistency across designs and includes detailed annotations (e.g., notes on requirements, interactions, flows, edge cases, accessibility considerations, and any non-obvious behaviors).
- Index of Links to Context/Supplementary Materials: A centralized page or frame with hyperlinks to external resources, such as Confluence pages (e.g., user stories, technical specs, API details, or research findings).
- Parked Items: A section for designs, ideas, or features that are deferred for future iterations and explicitly not part of the current development goals (to avoid confusion).
The process assumes that designs are created and iterated in the Product Figma project. Once a design (e.g., a scenario page or set of screens) is accepted (e.g., after stakeholder approval in a Design Review meeting), it's copied to the Development Figma project for handover. This ensures the Product project remains focused on exploration and iteration, while the Development project is streamlined for implementation.
I'll describe the general handover process first, then address the specific contexts you mentioned: adding new work orders, updating existing tasks, and archiving/moving pages.
General Handover Process
This process is triggered when a design is accepted and ready for development. It involves the UX/UI designer (or a designated handover lead) and ensures developers have everything needed without ambiguity.
-
Design Acceptance and Preparation (in Product Figma Project):
- The UX/UI designer finalizes the design in the Product Figma project, ensuring it's reviewed and approved by stakeholders (e.g., via Design Review meetings).
- Add any necessary annotations, variants, or notes directly to the screens to clarify requirements (e.g., "On hover, display tooltip with X content" or "Error state: Redirect to login if API fails").
- If a prototype was created for reviews, note that it's for reference only (not specification-grade).
- Gather supplementary materials (e.g., Confluence links) and prepare an index of them.
-
Copy to Development Figma Project:
- The UX/UI designer duplicates the accepted scenario page(s) or screens from the Product Figma project to the Development Figma project. (Use Figma's "Duplicate" or "Copy/Paste" features to maintain links and components.)
- Do not modify the original in the Product project—treat it as archived once copied.
- Organize the copied content into the four sections immediately:
- Place the basic prototype (if it exists) in the Prototype section.
- Move all finalized screens, variants, and annotations to the All Screens and Variants section.
- Create or update the Index of Links section with hyperlinks to Confluence pages or other resources.
- If any elements are identified as out-of-scope, move them to the Parked Items section with a clear note (e.g., "Deferred to Q3: Not in current sprint").
-
Handover Notification and Review:
- Notify the development team (e.g., via Slack, Jira ticket, or email) with a direct link to the Development Figma project and the specific sections.
- Include a brief handover summary: e.g., "Handing over Scenario X – Focus on 'All Screens and Variants' for specs. Prototype is for flow reference only."
- Schedule a quick handover meeting (e.g., 15-30 minutes) if needed, where the designer walks through annotations and answers questions. Developers can add comments in Figma for clarification.
- Update any associated task-tracking tools (e.g., Jira) to mark the design as "Handed Over" and link to the Figma sections.
-
Post-Handover Maintenance:
- The Development Figma project is now owned by the development team, but the UX/UI designer remains available for questions.
- If issues arise during implementation (e.g., feasibility concerns), loop back to the designer for updates (see "Updating Existing Tasks" below).
- Regularly audit the project to ensure it doesn't grow bloated—archive old content as needed (see "Archiving" below).
This process ensures clarity, reduces miscommunication, and keeps the handover efficient (typically 1-2 hours per scenario, depending on complexity).
Process in Context: Adding New Work Orders to Developers
When introducing entirely new features or scenarios (e.g., a new user flow or UI component), the handover focuses on fresh content without disrupting ongoing work.
- Trigger: A new task is prioritized in the product backlog (e.g., via Jira), and the design is accepted.
- Steps:
- Follow the general process above to copy and organize the new scenario page into the Development Figma project.
- Create a new "work order" in your task-tracking system (e.g., Jira ticket) with links to the relevant Figma sections. Specify: "Implement based on 'All Screens and Variants' – Annotations detail interactions. Use 'Index of Links' for Confluence specs."
- If a prototype exists, note it's optional and for high-level flow only—developers should not build directly from it.
- Park any exploratory ideas (e.g., alternative designs) in the Parked Items section to avoid scope creep.
- Notify developers and assign the task. If the new work relates to existing features, cross-reference it in the Figma index to provide context.
- Best Practices: For new work, emphasize annotations in All Screens and Variants to cover edge cases early, reducing back-and-forth.
Process in Context: Updating Already Passed-Over Tasks
If a design that's already been handed over needs changes (e.g., due to feedback, bugs, or scope adjustments), updates are versioned carefully to avoid confusion on live tasks.
- Trigger: Changes are identified post-handover (e.g., stakeholder feedback, QA findings, or technical constraints).
- Steps:
- Make updates in the Product Figma project first (e.g., revise screens, add variants, or update annotations). Get quick approval if needed.
- Copy only the updated elements to the Development Figma project—do not overwrite the entire section to preserve history.
- Version the updates clearly:
- Create a new frame or page in the relevant sections (e.g., "Scenario X - v2" in All Screens and Variants).
- Update the Index of Links with notes like "v2 Changes: See Confluence page for rationale."
- If the prototype needs updating, duplicate it as "Prototype v2" (still optional).
- Move any deprecated elements to Parked Items with a note (e.g., "v1 Deprecated – Do not implement").
- Notify developers immediately (e.g., via task comments or a meeting) with links to the updated sections. Update the associated Jira ticket to reflect the changes and reassign if paused.
- If the update affects in-progress development, pause work briefly for a sync to discuss impacts (e.g., "This changes the error flow—see annotations").
- Best Practices: Use Figma's version history or comments to track changes. Limit updates to essentials to avoid disrupting developer momentum.
Process in Context: Moving Scenario Pages from Shared File to Individual File (for Archiving and Size Management)
As the Product Figma project grows, it's important to archive completed or obsolete content to keep it manageable (e.g., prevent performance issues from large files). This doesn't affect the Development project directly but ensures clean handovers.
- Trigger: A scenario page is fully handed over, deprecated, or no longer active (e.g., after implementation and QA).
- Steps:
- In the Product Figma project (the shared file), identify pages ready for archiving (e.g., completed scenarios from past sprints).
- Duplicate the page(s) to a new, individual Figma file (e.g., named "Archived - Scenario X - Q2 2023"). This creates a standalone archive without deleting anything.
- Remove the duplicated page from the shared Product project to reduce its size. Add a placeholder note or link in the shared project (e.g., "Archived – See individual file: [Figma link]").
- If the archived content relates to an ongoing handover, update the Index of Links in the Development Figma project with a reference to the archived file (e.g., "Historical designs for reference: [Archived Figma link]").
- Notify the team (e.g., via a shared wiki or email) about the archive move, especially if it's for compliance or future reference.
- For the Development project, if an entire section becomes obsolete (e.g., after full implementation), move it to a dedicated "Archived" page within the project or to its own individual file.
- Best Practices: Set a cadence (e.g., end of each sprint) for archiving. Use Figma's file organization features (e.g., teams or folders) to group archives. This keeps the active projects lean while preserving history—aim for shared files under 100-200 pages to maintain performance.
This process promotes collaboration, minimizes errors, and scales as your projects grow. If your team uses specific tools (e.g., Jira integrations with Figma), customize notifications accordingly. If you need templates, checklists, or examples for any part of this, let me know!
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.