Strategy question

Figma wants better connectivity to enterprise codebases, but customer stacks, component systems, and developer workflows vary widely. How would you work with enterprise customers to identify the highest-value integration problems, segment the opportunity, and convert those findings into a prioritized roadmap for Roundtripping?

Practice this question out loud. An AI interviewer asks it, follows up like a real interviewer would, and scores your answer. Type or speak.

What this question tests

Whether you can turn broad enterprise customer variance into a structured, prioritized integration roadmap rather than chasing one-off requests.

Run structured discovery with a representative sample of enterprise customers spanning component-heavy design systems, custom token pipelines, and different frontend stacks (React, native, web).
Segment the opportunity by integration pattern rather than by customer name, for example token synchronization, component library mapping, and round-trip code diffing.
Score each pattern by how many enterprise accounts hit it, the engineering cost to solve generally, and whether solving it unlocks a broader workflow (for example fewer manual handoffs between design and engineering).
Convert the top patterns into a roadmap sequence, starting with the integration that removes the most manual re-implementation work reported in discovery.
Validate the prioritized list with a second round of customer conversations before committing engineering resources.
Set a success metric per roadmap item, for example percent reduction in manual token reconciliation reported by pilot customers.

Segments by integration pattern, not by customer, since Roundtripping needs to generalize across many different codebases.
Names a concrete pattern likely to be high-value, for example design-token to code-variable synchronization, since that recurs across nearly every enterprise design system.
Uses a two-pass validation process: initial discovery to generate hypotheses, second pass to confirm prioritization before committing engineering.
Ties prioritization to a measurable outcome (reduced manual reconciliation work) rather than customer satisfaction alone.

Building a roadmap driven by the loudest enterprise customer instead of a generalizable pattern.
Skipping validation and locking in a roadmap after one round of interviews.
No metric to know whether an integration actually reduced customer effort after shipping.

How would you handle a large customer whose integration need does not match the top pattern?
What would you do if two integration patterns score similarly but only one has engineering capacity this half?
How would you validate that a pattern generalizes beyond the customers you interviewed?