Nested folders: rebuilding Figma's file architecture

Nested folders are now live in Figma, a long-requested feature aimed at helping growing teams organize files as they scale content and take on complex projects. What sounds like a straightforward quality-of-life improvement actually required rethinking Figma's underlying content and permissions model from the ground up — spanning the file browser, admin controls, sharing, permissions, and core infrastructure.

When the project began about a year ago, the team followed a conventional product development trajectory: Product defined requirements, design mapped the experience, and engineering started building once the thinking felt settled. Midway through, the context shifted. The team was simultaneously pursuing new AI-native capabilities that split its resources, while tools like Figma Make, the Figma MCP server, agent skills, codebase prototyping, and context-aware agents made it far faster to turn an idea into something tangible. Building could start anywhere: with a prototype, code, or even something scribbled in Slack.

To match these shifts and ship nested folders, the team adopted a different way of working:

  • Led with code: As code became cheaper to produce, the team moved faster by spinning up pull requests (PRs) to test ideas instead of getting lost in theoretical discussions.
  • Shifted responsibilities: Flexibility was key, so engineers made design calls, a designer pushed code, and the product manager traded day-to-day execution for larger strategic questions.
  • Exchanged handoffs for conversations: Blurring roles made everyone both student and teacher, and sharing the parts of their craft they used to guard built the trust the work needed.

Software Engineer Ethan Adams on reaching new velocity with code

Ethan Adams, software engineer at Figma, realized a few months into the project that the typical product development process would take too long. Rather than debating product requirements — like who should have access to what — in sprawling Slack threads or meetings, the team led with code as the proposal. Those discussions had been valuable prerequisites when writing code was expensive and time-consuming, but with agents available, the team could simply spin up a PR to prove an idea.

Code was merged as long as it didn't break anything, making it possible to quickly sketch ideas and show them to cross-functional partners in a real, live testing ground. Imperfect copy, lacking functionality, or logical gaps were all acceptable at that stage. In practice, this was a huge unlock for velocity and built confidence in the proposals eventually selected. A working demo in the actual codebase beats a Product Requirements Document (PRD) every time.

Adams still relied on Product Manager Sachi Shah as a thought partner to share ownership. Their collaboration used to look like a waterfall: Shah decided a requirement, and Adams implemented it. This time, it looked more like a verification loop: Adams led with a proposal, merged prototypes into staging, solicited feedback from Shah, smoothed out rough edges, and finally deployed the finished product.

Product Designer Cai Charniga on going from pixels to pull requests

Cai Charniga, product designer at Figma, admits their PR count was low for this project — two, maybe three. But instead of any single person magically crossing over into another discipline, the whole team started stepping into roles that used to exclusively belong to someone else.

On this project, the engineers had strong instincts for structure and a deep understanding of how complex enterprise permissions work inside a tool like Figma, so they regularly came to Charniga with flows and design tweaks. When a strong design system gives people guardrails, and enough trust exists for them to make the call, an engineer can go deep on a design feature and get it to a solid state. When someone was at capacity, the work didn't stall waiting for the right person to pick it up.

For example, while working through folder sharing flows — how the share modal should communicate inheritance for users with view or edit access, and how to handle trickier cases where inheritance is broken — Software Engineer Jenny Yu stepped in and mocked up options. From there, Charniga brought in UX Writer Molly Rosen Marriner, and the three built on Yu's approaches on the Figma Design canvas: Yu keeping the flow technically sound, Marriner sharpening the permissions language, and Charniga shaping the visual hierarchy.

It ran the other way as well. There were times Charniga picked up a change, got into the code, and realized how much was happening under the hood — enough to go back to the team and say, "Honestly, this one shouldn't be mine." Knowing where your expertise runs out is its own kind of craft. Still, Charniga believes every designer should try to push a PR. When Adams set up CoderBox, a sandbox for spinning up code environments, Charniga felt how long certain changes took to build before they could even be previewed — which did more for empathy than any handoff ever had.

Engineers could carry design work, and Charniga could get into the code directly. That created room to go deep where it counted, running through more versions of the folder UI than the old handoff model would ever have allowed.

Trust as a product strategy

Product manager Sachi Shah found the shift to a blended team model required surrendering a familiar assumption: that product insight had to originate with the PM. Her role refocused on pairing people with problems, enabling them to work autonomously, and deciding when to re-engage.

On the critical content operations work—moving, duplicating, and transferring folders—software engineer Jenny Yu became a close thought partner. Ricky Zein, also an engineer, took ownership of the individual-user and small-team experience, which often diverges from enterprise needs. Data scientists Patrick Kehinde Jr. and Eric Aberbook examined how the new permissions model would affect each user cohort, allowing the team to validate assumptions and flag the highest-risk areas.

The shift in execution responsibilities also opened space for a deeper strategic question: In an AI-first era, does better file organization still matter, or does improving AI search make folders obsolete? The team built artifacts showing that folders could grow more important as users create more content—providing AI search with richer structure and context to draw from. Stepping back from day-to-day PM duties made room for a balanced portfolio of work. Alongside nested folders, the team shipped skills for the Figma agent, another piece of the AI-native strategy. Deliberately spending less time on micromanaging details actually freed up room on the roadmap for both foundational customer needs and new AI experiences.

Within the project, Shah redirected most of her attention toward customers. She took charge of the early-access program (EAP) and adopted a scrappy recruiting approach. At Config, she and Engineering Manager Ayush Mehra worked happy hours, cold-pitching attendees on the new file-organization system and landing several EAP signups on the spot. The program continued to expand from there: Friends of Figma communities in Jaipur, Barcelona, Mumbai, and Lahore became early adopters, as did community leaders and vocal advocates on X—including designer Ilya Miskov, who had joined early discovery conversations.

Real-world feedback from the EAP showed how nested folders performed inside active organizations with messy file structures and established workflows. It surfaced bugs, helped refine the experience, and minimized the risk of moving current customers onto an entirely new content model.

Direct customer time gave Shah a product clarity she couldn't get from writing specs alone. The result of trading direct control was stronger conviction, built by stepping into the work she was best suited for and trusting teammates to do the same. That trade only functions with shared trust. Shah is candid about the awkwardness of blurred roles: toe-stepping, clumsy boundary crossings, and attempts at unfamiliar tasks were common. The discomfort was a natural part of finding a new operating rhythm, and the team only moved through it because they had already invested in the working relationships. Eventually, ownership of individual domains loosened, and team members began teaching each other the parts of their craft they’d previously guarded closely.

Shared routines kept trust and context intact: weekly bug bashes, cross-functional syncs, live pairing between design and engineering, and milestone celebrations—including launching internally across all of Figma. These rhythms kept everyone aligned on a common goal: delivering on a long-requested customer promise without compromising quality.

Nested folders are rolling out to all users over the next few weeks. The help center has instructions for getting started.

Ethan Adams is an engineer at Figma. He holds a patent, has published a peer-reviewed research paper, and released an EP to millions of listeners. Cai Charniga is a product designer at Figma and founded the company's DesignOps function; they also do professional tattooing from a private Brooklyn studio. Sachi Shah is a product manager at Figma, with a self-designed degree in Leadership in Creative Enterprise from Carnegie Mellon; outside work, she paints figurative oil works and trains in Muay Thai.

Get started with Figma for free.