New Ideas and Unique Solutions from Figma on Accessibility

Illustration of a collaborative design app with two windows, A11y is selected and being resized, a speaker icon with dashes indicating the screenreader is reading the page, and the Figma F logo.

This article is based on a talk David Winslow, software engineer at Figma, gave at A11yNYC.

For those who aren’t familiar with it, Figma is a tool that allows people to share and collaborate on designs for digital products and experiences. Changes are propagated in real time. Think of it as Google Docs for designers.

There are two products. There is Figma, the design platform. And there is  FigJam, which is more focused on meetings, brainstorming, and more creative, less structured content creation — a whiteboard-type product.

Dylan Field and Evan Wallace started Figma while they were at Brown together. They landed on the idea for Figma, something that brought design onto the web and made it multiplayer. What’s interesting is that two-thirds of Figma’s users are users who do not identify as designers.

Why Accessibility Matters to David and Others

Why does David work on accessibility? Why does it matter to him? He sees this as important work because he believes in enabling serendipity and building tools that empower users to do things that he didn’t imagine. The more people that can use the tools that he builds, the more opportunities there are for things that wouldn’t have happened otherwise to happen.

He also understands that Figma has a huge influence on the design community. By leading in this space, employees have the potential to influence beyond Figma.

As a software engineer, he believes they can do a better job if they take the time to identify what are the semantics of the user interface, what it means, and what patterns they should implement. It will make the product better for everyone, and not just by implementing accessibility. But also, by thinking about the accessibility or the semantics of the product, in ways that enable accessibility, as well as other experiences.

Accessibility on the Web

What is accessibility on the web built on? What are the tools for doing this? On the web, documents and user interfaces are made using HTML. A designer can make a button by taking the label that they want for the button and wrapping it in angle brackets that say: Button.

This makes an object in the browser’s memory called an HTML button element. That button element is responsible both for making the browser draw a button on the screen as well as for telling assistive technologies like screen readers there’s a button here.

Everything that the web communicates to the screen reader comes from some HTML element. As you dive into the tools, you need to build more interactivity. That’s where things like headings and landmarks help identify the different structures in a web page. There are tools for customizing both the behavior and the appearance of these things. Those are generally developed using JavaScript and CSS.

As designers get into more advanced user interfaces, there will be some required behavior that’s not provided by the browser. So, if you want to make a button in your user interface, the browser handles a lot of the behaviors that are expected of a button. For example, making that button clickable through the keyboard.

But if you want to make a menu, for example, you’re going to have to provide some JavaScript that provides the expected behaviors. Every accessible element comes from an HTML element and may require additional work from developers and designers. There is a lot of HTML that may not need to be communicated to the assistive technologies.

Accessibility in Figma

When David worked on mapping software, his company had a common request from users asking how to make their maps accessible. It’s common to look at a map from the U.S. Census, where you click, and then it tells you information about one place on the map. That’s a challenge to make accessible.

Often, the advice was to provide a table. He learned that sometimes the right way to make something accessible is to provide an alternative. This experience was one of David’s first introductions to thinking about accessibility, thinking about people interacting with computers in ways different from the way he does.

He worked on Google’s preview technology. This is the tool in Google Drive and several other Google products that lets you see content that you uploaded but didn’t author in Google Docs. Things like PDFs and spreadsheets didn’t map perfectly to HTML. Instead of relying on the browser, the team worked with their own rendering technology.

These services were screen reader accessible. This exposed David to a mature product that was in maintenance mode. It helped him understand what a mature accessibility practice can look like. Now, working at Figma, where they have a complicated data model. They have documents inside of documents inside of documents.

Regarding Figma’s specific problems not related to Canvas, one of the technological changes that enabled Figma to exist in the first place was the availability of this technology called WebAssembly. This lets you opt out of some of the things that make web applications slow, by writing them in C++ instead of JavaScript.

So, a lot of Figma uses JavaScript, and the graphics card on a fast desktop computer, to do things about as fast as a browser could be expected to do them. The vision was that Figma would build a cross-platform technology in C++ with a thin layer of web technologies, adapting it to the browser. It would also have a thin layer of MacOS technologies, adapting it to the MacOS platform.

Some of those layers of abstraction are in the product today. They don’t account for the things that you need for accessibility to tell the screen reader that the layer on your Figma Canvas exists. There’s been a lot of care given to the Figma UI.

Even if it doesn’t have all the right roles to make a screen reader understand it, there is a lot of thought given to the way that you can drag in almost any number control on the Figma properties panel to visually — or interactively — change its value.

Another example is every menu in Figma allows you to click on the menu and then move your mouse to the item you want and click on the item as well as hold the mouse down and drag it to where you want it to be. This is a common thing in native toolkits. It’s also a thing that a lot of web toolkits, a lot of things built from scratch, don’t always provide.

Another place where a lot of care is given is performance. As the team added features that use more of the web technologies that Figma was really planned around, they had to make sure that they were not impacting the performance in a way that was going to make Figma less usable. Especially for users who might not understand why the accessibility improvements are improvements.

The other thing is that there are a lot of people working on Figma. Not all of them are trying to build that new accessibility feature. Many of them see accessibility as something that’s not important right now. But accessibility is one of those things, like security, like performance, that’s kind of hard to retrofit into an application. Getting that work to happen sooner is something that David would like to happen as they build their practice.

Figma relies a lot on designers using the product internally for QA testing. They don’t have a ton of dedicated QA resources. It’s mostly designers contacting us on Slack, saying: “Hey, I noticed that this thing is 6 pixels apart instead of 8 pixels apart.” And that has served Figma well for a long time. It’s an area where they’re building and growing their maturity. It’s growth.

Figma Accessibility Philosophy

Figma doesn’t have users internally who are thinking about using a button instead of a link. Or, how a menu isn’t communicating its state properly to the screen reader. The features the Figma team builds must be careful to provide automated testing or some other means to make sure that they don’t get changed inadvertently, as a part of other work. That’s another challenge they face.

Figma has its own user interface. So, when they’re editing designs, the team tries to keep that user interface out of the way. This lets the designers’ experience focus on their own content. Figma doesn’t want its layer browser to prevent anyone from seeing the layers that they’re working on the canvas. The content itself is an important part of the Figma experience. And it needs to be accessible along with the menus around it.

In thinking about user-provided content, Figma knows that they probably won’t always be able to guess what an author means in a particular design. They may be able to do the right thing automatically in a lot of cases. However, for the best accessibility in Figma, it will need to give designers the power to design their documents.

If Figma tries to require things like accessibility roles in designs, then it introduces most users who have workflows that are working for them today and don’t require those things. Hence, Figma needs to make this possible, but optional.

One example is in FigJam whiteboarding. People like to just grab a GIF and put it in. There are lots of different contexts in which people put images into FigJam. One thing the company did while improving accessibility was to add support for alt text. But it’s opt-in.

You can still just drag and drop that image. And if you don’t put alt text, then there won’t be alt text. But if you have someone on your team that you know would benefit from it, then you can make that a practice that your team adopts.

Figma Accessibility Strategy

Figma knows they have a lot of work to do. That said, they look at the smaller pieces that they can deliver to users and celebrate. They’ve been focusing on enabling use cases rather than meeting technical criteria. For example, Figma prefers goals like “Support commenting without a mouse over and ensure that every menu responds to arrow keys appropriately.”

That’s why they’ve shipped things like the ability for screen readers to understand prototypes, as opposed to having incremental updates to the system that makes sure every dialogue in Figma traps focuses the way that it’s supposed to. Figma Files are an important part of the Figma Platform from the accessibility perspective. They want to make progress transparently and ship things that make things better for some users.

The Figma Canvas did not have screen reader transparency before and now it has some. Users have told Figma that it enables, for example, blind accessibility experts on some teams to review designs in some capacity, without needing someone to read them to them. Or without needing them to be exported to PDF with all the complications that that entails.

The launch of the Figma screen reader support for prototypes was one of the top posts on LinkedIn in 2021 when it came out. The company is collecting the stories they get from customers who are part of the beta programs. These folks can back up that Figma’s work is making a difference. This makes it easier to justify more investment in accessibility.

They’re working to identify partners internally who aren’t on David’s team. These partners care about accessibility and they’re helping them to care for and support each other, and enabling them to share what they know, teach each other, and build on the same systems.

Products

The prototype viewer was the accessibility team’s first project. The big challenge they had to solve was accessibility for the Canvas. They had to improve a lot of the incidental UI that’s around the prototype viewer. David’s presentation took place through Figma’s prototype viewer. (View the video to see it in action.) The viewer has its own menu, buttons, and toolbars. As you tab through the UI, it shows you where the focus is currently.

Figma Prototype Viewer

Every Figma prototype has a baseline level of accessibility for screen readers. The team opted to focus on broad support rather than fine control for designers. This ensures every prototype can be accessed with a screen reader.

How does it work? HTML manages all the text and they’re styled with CSS to avoid interfering with the visual presentation. HTML supports screen readers and other assistive technologies. To mitigate the performance impact of having many objects, Figma prefilters the design. Many of the objects don’t make sense for the screen reader and are filtered out.

A user who relies on the screen reader receives a link to a Figma prototype. They go there and there’s nothing there. To help the screen reader, the team added an invisible “skip to content” link. When someone uses that link, it turns on screen reader mode regardless of whether you have an account, are in incognito mode, or anything.

If you don’t “skip to content” and you find yourself at the main UI without having gone through that pattern, then there’s an explanatory text that takes the place of the dynamic canvas that tells the user how to activate it explicitly.

The team has learned designers use Figma in different ways. It’s hard to generalize across all of them. They found some designers that were deep into using components and switching properties around and saying: This is the same object, but it’s changing state. This is helpful feedback for the team.

They’ve also found users who build their Figma designs more like a PowerPoint by navigating to another slide. This is more difficult to support. They’ve also learned that there are many assistive technology users and they’re not all familiar with all the features.

The accessibility team gets a lot of support requests. They meet with the user, do a little investigation, and find that they just turned off speech in their screen reader. The team has no control over this aspect and it’s difficult to design for such challenges that aren’t part of Figma.

FigJam Accessibility

FigJam takes a similar approach. However, throttling was not effective in FigJam. It has little control FigJam can’t create autolayout. Users can copy and paste a design from Figma that has it. But generally, FigJam designs are shallow and simple from a nesting perspective.

The team found they needed to throttle how frequently it updates. FigJam can update multiple times a second, but it doesn’t have real-time text updating the way prototypes do. Generally, the screen reader will also throttle. You can’t send 60 frames per second of text updates to the screen reader. It doesn’t make sense. This was an accessible trade-off.

The team had to define some new UI patterns. They added keyboard-only flows for inserting content into the FigJam canvas. They adopted a pattern that is seen in tools, such as Microsoft Office, where there’s a special keybinding that moves focus to different areas of the UI.

The team added alt text for images. You can click on an image and one of the options that you have for manipulating it is to change its alt text. FigJam allows users to quickly react to a sticky note and other content using a keyboard shortcut. This is accessible and supports collaborative brainstorming and meetings.

Lessons Learned

FigJam is the first project in that the team spent a lot of time looking for exemplars and trying to figure out who is solving the same problems and doing it well. The team talked to users and experts at Fable. They all advised looking at what Microsoft does.

It was challenging to support multiple screen readers. This is the case as FigJam deals with more custom behavior. The team knows enough about the interactions for the sighted user. They needed to make sure that they were not conflicting with screen reader shortcuts and that they behaved acceptably in every supported platform. It was a balancing act of multiple screen reader applications.

The process involves mostly engineering time. The engineers have had to step out of their coding space and think about designing these new interactions. They think about keyboard shortcuts to ensure they don’t conflict with the existing a screen reader user or a keyboard-only user might try. They also consider the impact on the visual experience.

The engineers did have some support from designers in a review capacity. The engineers would make a proposal and the designers will let them know if it works or needs revisiting. The team partners with Fable on testing and consultation about the designing of the interfaces.

When you’re editing your design, even if you want to design for screen readers, there’s nothing in the editor that’s telling you that it will be read to the screen reader. This is a link. This is going to be skipped over. It’s crucial to have some way in design to know what you’re doing for the prototype.

Figma continues to work with Fable. It’s a ripe time for Figma to invest in its foundations by working on some of the legacy codes that are not written with accessibility in mind. They’re also working to consolidate common patterns into a small number of implementations and build out core components. Implementers at Figma need better tools for testing and validating that the accessibility measures they’ve made are protected against future changes.

One cool and surprising side effect of doing this work has been that people who care about accessibility at Figma are starting to reach out to the accessibility team. The accessibility team is becoming that focus, that lightning rod. Many voices are saying that the competency and drive to do this work exist at Figma. The key is to align it and give it the resources that it needs to get off the ground, and there’s a lot of capacity for Figma to do the things that need to be done.

Resources

Video Highlights

Watch the Presentation

Transcript: Accessibility at Figma - David Winslow

DAVID WINSLOW: So my talk today is about accessibility at Figma.

I really appreciate being invited to speak tonight. Cameron reached out to me, and I was really happy to have the opportunity. I'm gonna talk a bit about myself. To introduce the talk.

I'm gonna talk about Figma's challenges and how we're approaching them in the accessibility space. I'm gonna talk about what we've accomplished and where accessibility is at Figma right now. And I'm gonna talk a little bit about what we're doing to prepare for the future. Yeah. So... My history...

I've been working on kind of similar apps for my entire professional career. Things like... Map viewers, PDF viewers, and freeform design tools now at Figma. Closer? Okay.

These are applications to take control of every pixel in a part of the screen on the web. And that brings its own challenges. Sorry.

Yeah. I'm just missing a slide. It's fine. Yeah. This is what I thought would be next. So...

When I worked on Maps, we had a common request from users of our mapping software, that was: How do I make my map accessible? It's really common to make a map, like this one, from the US Census, where you click, and it tells you information about one place on the map. And that's, like, actually kind of an annoying experience to make accessible. Right? And often the advice that we had for people was just to also provide a table. Right? And so my takeaway there is like: Sometimes the right way to make something accessible is to provide an alternative. Right?

And that was also one of my introductions to just thinking about accessibility, thinking about people interacting with computers in ways different from the way that I do. I also spent some time working on Google's preview technology. This is the tool in Google Drive and several other Google products that lets you see content that you uploaded, that you didn't author in Google Docs. And so especially for PDFs and spreadsheets, those don't map perfectly to HTML.

And so we didn't rely on the browser to draw them. We provided our own rendering technology there as well. But those services are also screen reader accessible. So this was exposure to me to a really mature product that was in maintenance mode. I still broke it sometimes. I had to fix it. Right?

So that was an experience for me, understanding what a really mature accessibility practice can look like. And now I work at Figma, where we have a really complicated data model. We have documents inside of documents inside of documents, really deep nesting, designers don't really tell us a lot about the content that they have. You know, we have this component system. But we don't know whether your component is a button or a heading or a page. And so we have to kind of recover that information. And we're doing things that just go beyond what browsers let you do. For example, we just launched P3 color support that is not a standard feature in CSS.

And we don't generally let the things that are doing CSS -- that are possible to do in CSS and browser technologies -- define what we allow designers to describe in Figma designs. And so mapping back to the web and the accessibility primitives on the web is a problem there.

Yeah. And then one other note: When I asked for internal feedback on this talk, in preparation for this week, my colleagues recommended that I talk a bit about myself. Why am I working on accessibility? Why does it matter to me? And I had to reflect on that a little bit. I feel like this is the part in my talk where I should share a really impressive personal anecdote about somebody who I saw using the features that I've built to do things that they wouldn't have been able to do. Or someone in my personal life who was really impacted by accessibility issues. I don't actually have a story like that. Right? But I can see that this is important work, because I believe in enabling serendipity and building tools that empower users to

do things that I didn't imagine. And the more people that can use the tools that I build, the more opportunities there are for things that wouldn't have happened otherwise to happen.

I also understand that Figma has a huge influence on the design community. And by leading in this space, we have potential to influence beyond just Figma. And maybe we can bring some accessibility to all of the Figma community files that people are copying and building off of and riffing. And I also just think that as a software engineer, we can do a better job, if we take the time to identify what are the semantics of our UI, what does it mean, what are the patterns that we should be implementing, consistently. And so I think we will make the product better for everyone, not just by implementing accessibility features, but just thinking about the accessibility, or the semantics in our product, in ways that enable accessibility, as well as other experiences.

All right. So... Yeah. To talk a little bit about Figma... For those who aren't familiar with it, so Figma is in a nutshell a multiplayer design platform. It's a tool for designing mostly 2D experiences. People do use it for some 3D stuff. And the really interesting thing about it is that it's multiplayer. It's web-first. You can share a link to a Figma document. And other people will open it and be looking at the same document that you are. Changes are propagated in realtime.

That's, like, what Figma is. We have this platform for design on the web. We have two products right now. Figma itself is a tool that's really targeted for product development. And then we also have FigJam, which is more focused on meetings and brainstorming, and more creative, less structured content creation. Figma was started by Dylan Field and Evan Wallace while they were at Brown together. They applied to a fellowship and weren't exactly sure what they wanted to build with the money. They looked into a lot of ideas including drones before landing on the idea for Figma, something that brought design onto the web and made it multiplayer.

Figma is a design platform that is used by teams who build products together. And then of course, we have FigJam, the white board product. And these tools are used by individuals, and teams. All over the world. From individual contributors building their own things to companies like Uber, AirBnB, The New York Times, and I imagine many companies in the audience today. 2/3 of Figma's userbase are users who do not identify as designers. Fun fact. I mentioned that I think a lot about the technical issues of bringing accessibility to Figma. So let me dive a little bit into what accessibility on the web is built of. What are the tools we have for doing this. So on the web, documents and user interfaces are made using a technology called HTML.

We take text, and we add little bits of descriptives, inside of angle brackets. That tell the browser: This part of the UI is separate from that part of the UI. And here's what it means. So I can make a button by taking the label that I want for the button, and wrapping it in angle brackets that say: Button. This makes an object in the browser's memory called an HTML button element. And that button element is responsible both for making the browser draw a button on the screen, but also for telling assistive technologies like screen readers: Okay. There's a button here. Right? And so those are the tools we have. Everything that we communicate to the screen reader, it comes from some HTML element. And as we get into the tools we need to build more interactivity, we have things like headings and landmarks that help

identify the different structures in a web page. We have tools for customizing both the behavior and the appearance of these things. Those are generally developed using JavaScript and CSS. And then in many cases, as we get into more advanced user interfaces, there will be some required behavior that's not provided by the browser. So if I want to make a button in my user interface, the browser handles a lot of the behaviors that are expected of a button. For example, making that button clickable through the keyboard. But if I want to make, for example, a menu, I'm going to have to provide some JavaScript that provides the expected behaviors.

And just to kind of illustrate that, this is some HTML that I captured from the Wikipedia homepage. This is the title of the featured article section on Wikipedia's homepage, highlighted in blue here. This is the same content, filtered down to just the outline that's exposed to the screen reader. And you can see that there's a lot of extra stuff in the HTML view. Those generally affect the visual experience by adding additional borders and things like that. And then we'll strip out some of that. And so I guess that illustrates that every accessible element comes from an HTML element, but there's a lot of HTML that maybe doesn't need to be communicated to the assistive technologies.

But in applications like Figma, like maps, like Google Street Viewer, we have sort of the opposite problem. In these cases, for whatever reason, for Figma, a lot of it is about performance and flexibility, in other tools, it's just... That the... In the context of maps, we often found that you don't want each, like, road on your map to be a div. You just want to draw a picture and put it on the screen. And so we would have one object, one HTML canvas element, that represents a really complex document. Maybe it's a PDF that we've rendered to the canvas. In the case of Figma, it's whatever you want it to be.

And so for the screen reader, that's just one thing. It's effectively an image. And so... We could label it. But that's probably not sufficient for editing. Right? Like, we want to be able to navigate to specific parts of this thing. That as far as the screen reader is concerned doesn't exist. And that's really the problem that we've had to solve in all of these contexts.

But for Figma, creating a table with the equivalent of canvas content probably wouldn't pan out very well for us. So that's not the approach that we've taken. Yeah. And so just to talk a little bit about Figma's specific problems, not related to the canvas, yeah. So... One of the technological changes that enabled Figma to exist in the first place was the availability of this technology called WebAssembly. This lets us use -- this lets us opt out of some of the things that make web applications slow, by writing them in C++ instead of JavaScript. And so a lot of Figma, even today, is using JavaScript, and the graphics card on your really fast desktop computer, to really do things about as fast as a browser could really be expected to do them. And the vision, starting out, was that we would build

across-platform technology in C++. With a really thin layer of web technologies, adapting it to the browser. And a really thin layer of MacOS technologies, adapting it to the MacOS platform. And some of those layers of abstraction are still in use in the product today. And they don't really account for the things that we need for accessibility. And so we need to take them out. Or improve them. To support the features that we need. In order to, for example, tell the screen reader that your layer on your Figma canvas exists. There's also been a lot of care given to the Figma UI. Even if we don't have all of the right roles to make a screen reader understand it, there is a lot of thought given into the way that you can drag in almost any number control

on the Figma properties panel to visually -- or to really interactively -- change its value. Or another example that I like to give is: Every menu in Figma allows you to not just click on the menu, and then move your mouse to the item you want and click on the item, but you can also hold the mouse down and drag to where you want it to be. This is a really common thing in, like, native toolkits. It's also a thing that a lot of web toolkits, a lot of things built from scratch, don't always provide. And another place where a lot of care is given is performance. And so, as we add features that use more of the web technologies that Figma was really planned around avoiding, you know, we have to make sure that we're not impacting the performance

in a way that's going to make Figma less usable. Especially for users who might not understand why the accessibility improvements are actually improvements.

And then... Yeah. The other thing is that there's a lot of people working on Figma. And not all of them are my team. Not all of them are trying to build that new accessibility feature. Many of them see accessibility as something that's not important right now. We're experimenting, we're trying this new feature that -- we're not even sure we're going to ship to production.

We'll deal with accessibility later. But accessibility is one of those things, like security, like performance, that's kind of hard to retrofit into an application. And so getting that work to happen sooner is something that I'd like to see us do, as we build up our practice.

And then... Yeah. One more thing is that Figma actually relies a lot on designers using the product internally, for QA testing. We don't have a ton of dedicated QA resources. It's mostly designers contacting us on Slack, saying: Hey, I noticed that this thing is 6 pixels apart instead of 8 pixels apart. And that has served Figma surprisingly well for a long time. It's an area where we're building and growing our maturity. And it's not where I would like it to be at.

It's definitely in active growth. But we don't have users internally who are thinking about -- oh, you used a link here, where it should have been a button. Oh, this menu doesn't communicate its state properly to the screen reader. And so the features that we build, we have to be very careful to provide automated testing or some other means to make sure that they don't get changed inadvertently, as a part of other work.

And so that's another challenge that we've had to take on.

Yeah. And so... Some thoughts about just how do we approach taking on this complex problem.

One thing that I should mention is that: Figma has its own user interface. But especially when we're editing designs, we try to keep that user interface out of the way. So that most of the designers' experience is about their own content. We don't want Figma's layer browser to prevent you from seeing the layers that you're working on, on the canvas. And so... The content itself is a really important part of the Figma experience. And we need that content to be accessible. As well as the menus around it. And so... In thinking about that user-provided content, we know that we probably won't always be able to guess what an author means in a particular design.

We may be able to do the right thing automatically in a lot of cases. But we do anticipate that, for the best accessibility in Figma, we'll need to give designers the power to design in their documents. And the challenge there is that: They don't have to now. And so if we try to require things like accessibility roles in designs, we're introducing friction for the majority of users who have workflows that are working for them today, that don't require those things.

And so we need to make this possible, but optional. And, like, not in your face. And one example where we've already done this is in FigJam, where we have this whiteboarding product. People like to just grab a GIF and put it in. Right? There's lots of different contexts that people put images into FigJam piles in. And one of the things we did when we were improving accessibility there was to add support for alt text. But it's very opt-in. Right? You can still just drag and drop that image. And if you don't put alt text, then there won't be alt text.

But if you have someone on your team that you know would benefit from it, then you can make that a practice that your team adopts. And so it's still available for those that will benefit from it. And then one more thought here... We do have a lot of work to do. And we know it's gonna take a lot of time to do it. And so we want to think about: What are the smaller pieces that we can deliver to users and celebrate? Rather than work on this for years, and then deliver accessibility as a monolithic release. And at least to date, we've been focusing on enabling use cases, versus meeting technical criteria. For example, we prefer goals like: Support commenting without a mouse over: Ensure that every menu responds to arrow

keys appropriately. And so... That's why we've shipped things like the ability for screen readers to understand prototypes, as opposed to having incremental updates to our system that make sure every dialogue in Figma traps focus the way that it's supposed to.

And just to reiterate my first point, we see Figma files as a really important part of the Figma platform. From the accessibility perspective.

Yeah. And so, based on all of that, what we're thinking about, in terms of choosing what to do, is: We want to make progress transparently. We want to ship things that make things better for some users. And be able to talk about them in ways that are relevant to users who maybe didn't directly benefit. Right? And that was a big driver for the screen reader focus in our work so far.

Is that: It's an area where we went from zero to one. We had no screen reader transparency of the Figma canvas before. And now we have... Some. Right? We've heard from users that this enables, for example, blind accessibility experts on some teams to review designs in some capacity, without needing someone to read them to them.

Or without needing them to be exported to PDF, with all the complications that that entails. So we feel like we're making a real difference. It's something that we can talk about, and even if you're not deeply into accessibility, it's pretty easy to understand how a screen reader compatibility enables users who wouldn't have been able to otherwise access Figma -- can use it.

And we were talking about these things in social media. Actually, the launch of our screen reader support for prototypes was one of our top posts in LinkedIn, in the year that it was put out, in 2022. Sorry. 2021. Yeah. And we're also collecting the stories that we hear from customers who are part of our beta programs, to reach out directly to us, via their customer support representatives.

And that's how we hear from folks that -- like the designer that I just referenced. Who can really back up that our work is making a difference. And that makes it easier for us to justify more investment in this space. And we're also working to identify our partners internally. Folks who aren't on my specific team. Who care about accessibility for any of the reasons that it makes sense to care about accessibility. And helping them to care and support each other, and also enabling them to share what they know, teach each other, build on the same systems, and really kind of multiply the force that's applied there.

All right. So moving on to the state of what has currently been done by my team, I'm gonna talk a little bit about the screen reader mode that we've added for prototypes, and then I'm gonna talk a little bit about the screen reader mode that we've added for FigJam. And I just want to shout out, at this point, that there have been some other notable accessibility improvements to Figma in the time that we've been working on this. For example, in our launch of dark mode last year, we also included a review of every color in Figma. Every color in our own UI. To ensure that it meets contrast standards.

So... The prototype viewer was our first project. Like I mentioned, we've been trying to grow the team. So going back to the beginning, I was the only engineer working on this, when it started.

And now we have all these people. And some more. And yeah. So the big challenge that we had to solve was that first one, that key issue that I identified earlier. We had to solve accessibility for the canvas. And we had to improve a lot of the incidental UI that's around the prototype viewer. I'm demoing -- or I'm presenting this talk from Figma's prototype viewer right now. And it does actually have its own menus, its own buttons and tool bars. And they have some funny behavior. Like... They'll just disappear out from under your mouse, if you get back to your presentation. And we wanted to do that. But we also wanted to make sure that as we tab through, you can tell where the focus is. This may not be totally

clear to the folks in the back of the room. But there is a focus indicator that moves through that UI. And as long as that focus indicator is in the toolbar, we won't hide it. All right?

And so there's some custom stuff that needed to be done there. As well as this big main content area that we don't actually have that much insight into. Because it's coming from user-provided content. And it's not something that we have that much structure to. Yeah.

So... This is... So this is a screenshot of a prototype that I recorded myself, using MacOS's Voiceover screen reader with. It's demonstrating that we do have landmarks in this area. If you choose the main area, then it moves directly to the prototype canvas. And it allows you to navigate through. And read each text area. And anything that's interactive you can interact with through the screen reader. So... Clickable links. Clickable buttons in your prototype. You can also activity by using the spacebar with the screen reader.

And that's basically it. Right? We didn't give designers a lot of control. But this means that every Figma prototype has a baseline level of accessibility for screen readers. There is a toggle that the user has to switch on. Because of the performance issues that I mentioned earlier.

But you know, we chose to focus on broad support over, like, fine control for designers. And that means that every prototype can be accessed with a screen reader today.

Yeah. And so... How does this work? We actually add back all of the HTML that we avoided by using our custom canvas technology. And so we add all the text from your text blocks in your Figma design into paragraphs in the HTML. And we just style them with CSS, so that they don't actually interfere with the visual presentation. So we have all this HTML that only exists to support the screen reader or other assistive technologies. And then to mitigate the performance impact of doing that, we actually prefilter the design. So it's very common in Figma to have lots and lots of objects, and maybe most of them don't make sense to read to a screen reader.

Things like autolayout frames or just spacers. And so we really, like, pare down. And we found that in the most complex -- visually complex prototypes, we were able to filter down quite a bit. So this has been pretty effective in managing the performance. But we did hide the feature behind a toggle, because of the theoretical performance impacts. If somebody has a design with tons and tons of tiny text objects. That would be a problem for performance.

And so because this feature is disabled by default, it means that if you are a user who is fully reliant on the screen reader, someone links you to a Figma prototype, you come there, and there's nothing there. And so we had to think a little bit about the UI design for this as well. And so we followed a pretty common accessibility pattern. Which is to provide an invisible link. That's the first thing you get to, when you're tabbing through the page.

It says "skip to content". If you use that link, it implicitly enables the screen reader mode. Whether you have an account. Whether you're in incognito mode, or anything. It just turns it on. "skip to content", we know if you use that, you're using an accessible interaction pattern, so we switch on accessibility.

Also, if you don't trust the "skip to content", if you want to explore more, and you find yourself at the main UI, without having gone through that pattern, then we have explanatory text that takes the place of the dynamic canvas that tells the user how to activate it explicitly.

Yeah. And as I mentioned earlier, we also do the general review of everything that's not the prototype content in the prototype viewer. All the menus, all the sidebars. And improve the accessibility there. So some things that we learned from launching this feature. One thing is that different designers use Figma in different ways. And it's hard to generalize across all of them.

So we've found some designers that were really deep into using components and, like, switching properties around, and, like, really telling us: This is the same object, but it's changing state. Which is very helpful for us. But we also found users that were building their Figma designs more like a PowerPoint. Right? Where you can navigate to another slide, and so... Maybe when you click on a menu, it just quickly navigates you to another page that has that menu open. And that's a little more difficult for us to support. And then another thing that we learned is that there's plenty of assistive technology users out there. Screen reader users out there. Other technologies. Who don't know how to use them, beyond the basics.

Right? And so we've had lots of support requests coming in, like: This doesn't work. And been able to meet with the user, do a little bit of investigation, and find that they just turned off speech in their screen reader or... You know, anything like this. And it's not really something that we have a lot of control over. And designing for that is... (laughing) Difficult.

And then moving on to FigJam, FigJam takes a pretty similar approach. We still reflect the content of the canvas to invisible HTML elements. In the case of FigJam, throttling was not particularly effective. FigJam has so little control that we don't let FigJam users create autolayout. You can copy and paste a design from Figma that has it. But generally, FigJam elements are very -- FigJam designs are very shallow.

And pretty simple, from a nesting perspective. And so in general, everything in a FigJam design is relevant to the user, and makes sense to read to the screen reader. And so here we found that we needed to not just filter content, because there wasn't that much content to filter, but also throttle how frequently we update. And so we can still update multiple times a second, but we don't have that real live text updating, the way that we do in prototypes.

Generally the screen reader will also throttle. You can't send 60 frames per second of text updates to the screen reader. It doesn't make sense. So this seemed like an accessible trade-off for this feature. But we also had to define some new UI patterns. We added keyboard-only flows for inserting content into the FigJam canvas. And we also adopted a pattern that we see in tools, such as Microsoft Office, where there's a special keybinding that moves focus to different areas of the UI. And so you can use control-F6, or on a Mac, command-option-arrow, to move between the FigJam canvas and the FigJam tool palette and the FigJam main menu. So that those areas can be reached by a keyboard-only flow.

And then we did have one actually new feature, which is alt text for images. I mentioned that earlier. That's available today. You can just click on an image and one of the options that you have for manipulating it will be to change its alt text.

This is a demo of a debug tool that we use internally. And it's doing a lot of flashing and time-sensitive stuff. I don't want to suggest that I think this is a great accessibility pattern. But this is meant to reflect that we are doing focused updates. So the red flashes show which DOM elements are being changed, as we navigate and manipulate this document.

And if you look at the edges, you'll see that we are avoiding updates of things that aren't actually changing. And minimizing the amount of work that we have to tell the browser to do. Every change that we make to the web content might make the browser reevaluate event handlers or redo CSS layout. And so the more that we can avoid those types of updates, the better off we'll be. From that performance perspective.

And this is also -- this is a GIF that was shared by one of our design advocates. He didn't even talk to us. He just posted it on Twitter, like: Look at this cool thing. And as part of the FigJam launch, we added the ability to quickly react via keyboard shortcut, to stickies and other content on the FigJam board. So this is meant to help with collaborative brainstorming, and meetings. We let you put a sticker on somebody else's note. Prior to our work, this was something that required the mouse. You click on a stamp and drag it where you want it.

And we decided that we would have special support for this particular type of adding content to the FigJam canvas. Where you select something, and then you have a command-enter keybinding to add a sticker somewhere on that object. And our designer just loved that he can hold that keyboard shortcut down and stamp bomb something that he really loves. And I think this is a great example of how features that are developed with accessibility in mind can bring delight and utility to everyone. So this is probably a story that we'll be kind of drilling in internally. And wearing out. So what did we learn, in doing the work on FigJam?

This was probably the first project that we really spent a lot of time looking for exemplars and trying to figure out like: Who is solving the same problems as us? And doing it well? And we talked to users that we have. We talked to experts that we were connected to with Fable.

They were all like: Just find what Microsoft is doing. They've got this figured out. And this was also a much more challenging area for us, too. To support multiple screen readers in. We were doing a lot more custom behavior. Like I mentioned, in the prototype viewer, we're really just mapping your design to HTML. And we don't have a lot of custom behavior that's applied there.

In FigJam, we know enough about what the interactions are for the sighted user that we really do have a lot of custom experiences that we built into this. And making sure that they're available, that they're not conflicting with screen reader shortcuts, that they behave acceptably in every platform that we're trying to support, was much more of a balancing act. This time around.

Yeah. So I'll talk a little bit about our process. We've had mostly engineering time on these projects. And so our engineers have had to step a little bit out of their coding space and think a little bit about designing these new interactions. Figuring out keyboard shortcuts that don't conflict with the existing ones that are something that a screen reader user or a keyboard-only user might reasonably try. And also that don't impact the visual experience.

That we're not, like, adding too many new menu options that are going to make it difficult to visually scan that small menu that's designed to be really minimal and easy to navigate. And so we did have some designer resources. But they were mostly helping us in a review capacity. We would make a proposal and they would say: Well, this works. This is something that I think you need to go back and revisit. At Figma, all developers are issued Mac laptops.

And so we had a really VoiceOver-heavy testing practice. We do have access to one shared device with multiple other screen readers available on it. And so it's not like we're not testing in those screen readers. But everyone has VoiceOver much more easily than playing hot potato with that one laptop. We're working on that. It will be better later this year, I hope.

And then we've also been partnering with Fable. Thanks for hosting, Fable. Thanks for sponsoring. To do testing and consultation about the interfaces that we're designing. And that's been really invaluable, especially with, like I said, the more complicated experience that we had to design for FigJam. And yeah. So just thinking about this... One thing that I really feel is a failing of the current prototype experience is that it doesn't affect the editor at all.

So when you're editing your design, even if you want to design for screen readers, there's nothing in the editor that's telling you: This is going to be read to the screen reader. This is a link. This is definitely gonna be skipped over. And I think that having some way in design to know what you're doing for the prototype is really crucial. And I think we need to figure out how to provide that. And the other reflection that I have is... In FigJam, we deliver this feature, we met with the core FigJam team, and said... We built all this stuff for you. Let's collaborate on keeping it nice going forward. And they were like... Well, we'll talk to you at the end of building new features.

And how can we make accessibility less feeling like friction? So that it's able to happen and be considered earlier in the design process for new features. But... So far that collaboration is going okay. And the FigJam team has been supporting us in new features that they've launched. Like tables. Yeah. So going forward, what are we gonna do to extend this work and to continue to support the work that we've already done?

One thing that we're going to do is continue to work with Fable. They've been really helpful to us so far. And we actually just finished renewing our contract with them for another year. And yeah. Just... I don't know what we would have been able to do without someone providing us the services that Fable has provided. I think it's also a ripe time for us to invest in our foundations. Working on some of the legacy code that's not written with accessibility in mind.

And working to consolidate common patterns into a small number of implementations, building out our core components. And I think similarly, we need to give implementers at Figma, software engineers at Figma, better tools for testing and validating that the accessibility measures they've made are protected against future changes. Yeah. And then one other thing: A really cool and surprising side effect of doing this work has been that people who care about accessibility at Figma are starting to reach out to our team. We're becoming that focus, that lightning rod. And I'm really hearing a lot of voices, and it's telling me that the competency and drive to do this work exists at Figma.

And all we need to do is align it, give it the resources that it needs to get off the ground, and I think there's a lot of capacity for us to do the things that need to be done.

Yeah. So that's all that I had prepared today. Thanks for giving me the opportunity. CAMERON CUNDIFF: Thank you, David. That was exciting for me personally. And I think for everyone here, to see that work, and to see your expertise and commitment. Enabling serendipity is an amazing tag line for accessibility. So I appreciate you introducing that to me. I would like to open the floor for Q and A. If you have questions, which I imagine you do, raise your hand. PARTICIPANT: Hey, David. Thanks so much for the talk. We are also loving working with Fable. And just had a great first two weeks of dev...

Got a prototype over to them for feedback, basically, as early as possible. We've kind of just been bringing them earlier and earlier into each engagement. And I'm wondering: On your team, are you guys able to kind of do that rapid kind of feedback iteration cycle with them? Or is it a little more kind of staggered? Or just... Given your dev cycles, how early are you kind of getting that outside perspective in? DAVID WINSLOW: Yeah. So... Like I mentioned, we were kind of spinning things up, when I started work on the prototype viewer. And we didn't really engage with Fable until we were planning the release. We had opened that up to beta users, before we shared it with Fable. Funny story there... We shared a link to the UI that we

wanted them to test, and they said: Oh, no. We don't validate Figma prototypes. And we're like... No. That's the app. Right? This isn't a prototype. Our app is the prototype viewer!

(laughter) With FigJam, we were able to incorporate them, and incorporate Fable services into our process a little more rapidly. We did a lot of foundational work. So there were probably a couple of months that we were working on features. And then once we felt like we would be able to iterate quickly, then we brought them in, and we were doing multiple interviews on different parts of the UI that we were working on per week, at one point. Folks that were a little closer to the FigJam work -- any other comments about Fable?

Cool. PARTICIPANT: Hi. First of all, thank you so much for this presentation. This is really fascinating.

I am also really, like, interested in the metanarrative of all of this. Of, like, working on improving accessibility of a design tool, also potentially having an impact on the design practice in itself. I understand the friction that you're talking about, internally, at Figma. I'm really curious if perhaps the company's strategic direction towards making more tools for developers is... Has that been more of an entry point into making design accessibility more at the forefront of even the designers' experience? CAMERON CUNDIFF: Um... I'm not sure I totally captured the whole question. But... Like... I can say that I was working on accessibility before I was aware that the developer tools that were announced at the most recent config were being built. And it has certainly been a topic of a lot of conversation

for us this year. Of how accessibility work and developer mode are going to interact. And whether the features that we build for designers are going to make sense for developers, or whether they can... If they really need to be separate views of the same data. Yeah.

PARTICIPANT: Hi. Awesome presentation. Thank you. DAVID WINSLOW: Thanks.

PARTICIPANT: I was wondering: When you're engineering new features, do you ever build against public standards like ADA compliance, or is your main consideration what will be most helpful to your users? DAVID WINSLOW: Yeah. I think that what we've seen is that there's a baseline level of accessibility that's needed to have testing against those standards make sense. Right? I haven't... We haven't... We haven't done an audit or anything like that. But I am sure that the FigJam work has been a net increase in the number of, for example, WCAG violations that we have in our user interface, just because there's so much more of it that is inspectable by the tools that you would use to do such an audit.

So... The way that I'm thinking about it is: There are some things that we know we need to do. I keep mentioning, like, focus trapping. For dialogues. That's something that we don't do in most of our dialogues in Figma. It's very disruptive to screen reader users in particular to not do that. And I think there's some of these patterns that we know we need to do. They affect lots of parts of the UI. And we can centralize the implementation and have a small amount of engineering work affect all of the dialogues. All of the menus. And so... I'd like to see us invest a little bit in that type of cross-cutting work, before we let the standards directly guide our work. Yeah.

CAMERON CUNDIFF: David, I have a question. About machine learning.

DAVID WINSLOW: Okay. CAMERON CUNDIFF: It's a very hot topic. As you probably are familiar with, around image descriptions... Why not just throw AI machine learning at the canvas and have it tell you what's on it? That's the glib version of the question.

DAVID WINSLOW: Uh... Yeah, I mean... I haven't spent a lot of time considering that approach. I know that I have seen some discussion of tools that try to do this for final UIs. These plugins that you can just put in a web page and it says: This web page is accessible now. And I have not seen a lot of positive commentary from people that sound like they know what they're talking about, about these types of tools. So... I think we probably... I think Figma would probably have to advance the state of the art for that to be something that we'd be comfortable shipping.

But... This is a very thousand-yard view. I'm not that close to the machine learning side of this.

CAMERON CUNDIFF: If you'll entertain me, a couple other questions. Because this is near and dear to my heart. Around the FigJam prototype that you showed with the debugging information, I noticed that there are a lot of rectangles. And not a lot of curvilinear forms. Tell me about that.

DAVID WINSLOW: Yeah. I mean... I think that reflects that we test a lot with sticky notes that are easy to create. Sticky notes and sections. And I'll mention: I should have raised this during the talk -- like, sections are a really important part of the accessibility experience in FigJam.

They let you create headings that the screen reader understands how to navigate. They can be nested. So you can have multiple levels of sections. Multiple levels of headings. So if you are trying to include a screen reader user in your FigJam meetings, using sections more is a great way to facilitate them navigating. And yeah. We do support freehand drawing in FigJam. We have a number of tools that let you just drag on the canvas or create a line between two objects that moves when those objects are relocated. And those things can be read.

They do get positioned and communicated to the screen reader. And in both cases, the object that we share with the screen reader is going to be a rectangle. Web browsers are really fundamentally tied to rectangles. And so we don't tell the screen reader, like, this is an S-shaped curve. We tell it: This is a box, and there's something in it. And the screen reader is not going to fit the highlights that it shows.

Our debugging tool reflects the shape of the underlying HTML element and not the actual curve.

CAMERON CUNDIFF: Amazing. Thank you. Other questions? I'm gonna let go of the mic now.

(laughter) PARTICIPANT: You may have said some words about this at the beginning. And if you did, I apologize. I was curious just about the actual makeup of the sort of accessibility Task Force at Figma. Sort of...

It sounds like there's a broad scope of stuff. It's sort of the actual, you know, the accessibility editor, but also there's thoughts about how we make FigJam accessible, how we make the prototypes themselves accessible, and sort of the end product accessible. Is it... Are you just sort of a Task Force of people who are very interested in it? And are also sitting in a UX role or sitting in an engineering role? Or is it... I am an accessibility engineer at Figma, and this is 100% of my sort of purview? DAVID WINSLOW: It's closer to the latter.

Organizationally, I and my team are part of the core experience team at Figma. And core experience, until recently, well... Not that recently... Until last year, was called Editor Experience. But our domain is interactions with Figma's canvas technologies. So we own the code that lets you drag the edges of a box in your Figma design and change the size of those things.

And the adjacent stuff, like the properties panel and the layer explorer. And so... We were really well positioned to do the work that we've done so far. We have recently staffed a sibling team that is responsible for Figma's internal design system. Previously, that had been pretty diffusely owned, and now it has some full-time staff dedicated to it. And they'll be partnering with us on some of the more broad scoped changes. But yeah. This work, particularly in the applications, has been coming out of core experience. For the time that I've been working on it.

CAMERON CUNDIFF: Questions. PARTICIPANT: Thank you so much for this talk. This might be more tangential than the kind of core of what you were speaking about. But are there any tools or ideas for building in Figma of increasing support -- or tools not only for developers and people using Figma to make accessible prototypes, but in guiding them to design prototypes that will eventually be more accessible products?

Is that kind of in the scope of the work you're considering, or that's being considered at Figma?

DAVID WINSLOW: Yeah. I mean... I mentioned during the talk -- I would like to see us ship some features that make it easier, while designing, to understand what the accessibility implications of your design are. We are working on some stuff like that.

I don't want to go into too much detail, because it's a little ways off for us to ship it. But yeah. I think bringing some accessibility concepts into the editor is a good next step for our team. PARTICIPANT: Very cool. Thank you.

PARTICIPANT: So it wasn't quite clear to me if, in the main design experience, this paradigm you've described, of the parallel dimension reflecting the invisible HTML is your main approach that you're taking. Is that... True? DAVID WINSLOW: Um... We aren't... We aren't designing that out yet. We certainly could just take the code that we use in FigJam and run it again in Figma, the editor.

They share quite a bit of internal structure. And I think that code would actually just run as-is, if we wanted to do that. Figma designs tend to be a lot more complex than FigJam boards. And we're not sure... I haven't really decided where I think we should go with that.

Because it is true that when you're looking at a design, there's a lot of content that isn't something that you would read aloud if you were reading the page to someone. But at the same time, when you're in the editor, you want to be able to edit everything. And maybe this reflects that we should be having more modalities. I think we probably will be pursuing the same general approach. But the controls that we need to provide to make it usable -- we still haven't really explored. PARTICIPANT: Sure. So, I mean, if you think of your average piece of software, user interface is maybe like a room.

And there's locations and objects in the room. Figma would be like playing Capture the Flag, over, like, 2 acres, where the landscape is changing, right? And so in a context like that, how do you think about non-linear navigation? How do you get from the left panel to the right panel into the content area and then up to the tool bar and then somewhere else you want to go directly, right? And so... How do you craft that bespoke experience? Some of the things you showed there kind of pointed to a bespoke navigational approach. Right? But then the challenge kind of multiplies there in the main event. Right? And are you doing... You know, explicit focus management and stuff like that? Anything to say? DAVID WINSLOW: Yeah. So... We do have a bespoke navigation tool, this control-F6 keybinding that I mentioned. That lets you

bring focus to the UI elements that are sort of part of Figma's chrome. Figma's own UI. And so that solves navigating between the layers view, the properties panel, and the toolbars. Maybe it's not sufficient, but it's a start, for sure.

And I feel pretty bullish about the layers panel itself, as a navigation tool. The layers panel is a tree. Trees have pretty well explored navigation patterns. And Figma's layer tree is also now filterable with our search tool. So when you're in a design, you can type and search across layer titles and text element content, through the entire design.

You can choose whether that includes other pages and you can also filter by layer type. So I think some of those tools for filtering out parts of the design and understanding and using search to help identify parts of the design that you want to operate on are going to really facilitate the keyboard-only experience. And yeah... Something that I've been thinking about a little bit... It's not my primary work right now. So I don't have a totally complete design for you. PARTICIPANT: Yeah. Just a couple... Yeah. Just...

Sorry for hogging the mic. It's just interesting to see that... Even in your organization, you have a need to shift left, and you don't really have a proper core of accessibly informed designers or perhaps even QA. So this element of heroism, coursing over into masochism... You know...

And just one last question... Has your time there overlapped with Rasmus Andersson?

DAVID WINSLOW: No. PARTICIPANT: Oh, okay. Very interesting guy, right? Okay. CAMERON CUNDIFF: All right. I'm gonna take a couple questions from the livestream. We have a delightful bunch of folks over on the other side of this camera. So I would like to give them a little bit of air time. The first question is around semantics and what's available now in prototyping. You mentioned text. So generic text controls, also links. What else is there? Are there headings? Are there buttons?

DAVID WINSLOW: So... We make every page of your design an accessible section. If you use components, those are also groups. And then anything that has a click interaction defined on it becomes a button. And then we also use the formatting inside of text elements in your design. We can extract hyperlinks and ordered and unordered lists from your text content. So if you're using bullets in your Figma design, we'll communicate those to assistive technologies. CAMERON CUNDIFF: Nice.

DAVID WINSLOW: And there's an article repeating that in our help center as well. So...

CAMERON CUNDIFF: One more question. This is actually a celebration, almost. Saying that they work with many design tools, and accessibility is a huge advantage. This person had their organization choose Figma because of its accessibility. Is accessibility seen internally at Figma as a marketing advantage? Or strength?

DAVID WINSLOW: Yes. Yeah.

CAMERON CUNDIFF: Makes sense. And... One final question from the stream. How are you thinking about partnerships with assistive technology manufacturers? Like Freedom Scientific or NV Access, as you move forward in your journey with accessible authoring and prototypes?

DAVID WINSLOW: Yeah. That's not something that I've spent a lot of time on. Generally, as, like, an individual contributor, creating those types of partnerships is a little outside of my pay grade. I think that it would be great... There's probably some opportunities there, since we are doing something that's so specific...

But I haven't thought about what that type of partnership might look like for us.

CAMERON CUNDIFF: I'm gonna take one last question from the room. Yes. I saw your hand first.

PARTICIPANT: So how do you measure the success of the usability of the accessibility features that you've developed? Your user engagement -- what is the impact that you guys have seen so far?

DAVID WINSLOW: We've been primarily been... So the sort of systematic, the machine-managed measurements that we have, are activation. So we can track: Do users turn this on? Do users turn it back off? Once they have it on, are they using the mouse or the keyboard to interact with their prototypes and their FigJam documents? Those measurements...

I'll say that shortly after the prototype feature launched, which I had more responsibility for, we were talking about: What's the adoption rate? There's probably hundreds of people using this. And we were finding that the rate of growth was pretty consistently 5,000 users, month over month, for the first few months after launch. So people are using it. And that's what my focus is on. That's where I feel like our value is coming from.

But we can also look at: What's the response when we talk about these things in marketing contexts? And in social media? What are customers saying to us, through their support reps? And we are hearing that users -- or that designers -- we are hearing that customers, like, decision-makers at customer organizations, do consider accessibility as a high criteria.

And that the work we're doing enables the sale or a commitment to do this...

Within the next timeline. Enabled this sale. So those are some of the kinds of success that we identify. And how we choose to prioritize the work that we're doing.

Bio

David Winslow is a software engineer who enables screen readers to access Figma’s canvas technologies. In prior roles, he’s worked on document viewers for Google Drive and supported open-source map infrastructure for the Web.