Case study
Nobody Would Approve It. So I Built It Before Asking Again.
Two prototypes written at night turned an accessibility idea nobody could say yes to into a staffed product team.
Haim Repael · 3 min read

STAR AT A GLANCE
- Situation
- An accessibility plugin for Figma kept losing to a roadmap full of committed customer work, because nobody could answer whether it would work.
- Task
- Make the proof cheap enough that resourcing stopped being the blocker.
- Action
- Designed and coded two proofs of concept on my own time, with a deterministic classifier that identifies components and checks the rules that apply to them.
- Result
- Product and engineering staffed it for production. It is in development, and I sit on the steering team for its rules and first release.
My title said VP Design. Between midnight and three in the morning I was a very stubborn junior developer, staring at a classifier that had just declared a radio button to be an icon button. With total confidence.
That failure hurt. It was also the most useful thing the prototype ever did.
SituationAn idea everyone liked and nobody could fund
Our design system had grown past the point where anyone could eyeball whether a screen used it correctly. Every accessibility tool I knew worked on the live site, in the browser, after the product had already been coded and shipped. They cleaned up, at great expense, mistakes that were born on the Figma canvas.
Nobody, as far as I could tell, was checking earlier, inside the design file itself.
I raised it. More than once. For about two years it lost to a roadmap full of committed customers and dated deadlines. That was the right call. I could not answer the only question that mattered to product and engineering: will this actually work, and will it actually help?
TaskStop arguing. Lower the cost of finding out.
I did not have a good answer in words. So the job changed. Not convince the organization, but build the smallest thing that would answer the question with evidence, cheaply enough that I didn't need permission to try.
ActionBuild, break, rebuild
First, research as a living tree. I broke down the 164 WCAG 2.1/2.2 success criteria and W3C APG patterns, removed what only exists at runtime (server responses, load times) and distilled 34 measurable design rules a designer actually controls in Figma. Then I mapped browser concepts like combobox and aria-expanded to what Figma really stores: layout modes, variant properties, bounding boxes, strokes.
Then, the trap. My first instinct was heavy computer vision: screenshot the canvas and let an AI model tell me what it saw. It was a disaster. One frame cost over 15,000 tokens, took 8 to 12 seconds and froze Figma. One giant 970-line prompt stalled for three hours without output.
Then, the pivot: geometry over names. Designers name layers Frame 47 and Rectangle 54. Names lie. Structure doesn't. I built a deterministic classifier that scores each node across weighted signals: geometry, styling, structure, spatial position, variant keywords and content, with hard exclusions that drop a score to zero. When geometry is strong, the layer name barely counts. Icons are recognized with vector math, simplifying paths and reading their convex hull, without sending a single image to AI.
Only when confidence falls below 0.90 does the engine escalate to an AI model, as a safety net. Everything else runs locally, in under 20 milliseconds, at no cost per scan.
Then, the small dramas. Five star icons were each classified as a separate button, until a spatial engine noticed the words "Select one" sitting right above them and understood a rating radio group. Fixes failed silently, until I found the AI coding agent had replaced real node IDs with guesses. I removed the shortcut and made every fix target an exact Figma ID.
I tested against dozens of design systems and thousands of icons. From the first embarrassing version to the one I showed, accuracy improved by 41% and crossed the bar we had set for high accuracy.
Finally, the conversation. I didn't ask for a yes to an abstract idea. I put running code on the table.
ResultThe objections got specific
The questions changed shape. Not "should we build this?" but "this rule is wrong," "this edge case breaks it," "what is the smallest version worth shipping?" Every objection made the next version better. None of them was "this is impossible", because it was running right there on the screen.
Product and engineering looked at the second prototype and made the call themselves to staff it for production. The proof of concept left with over 2,200 lines of TypeScript, 48 automated tests and 43 auto-fix mechanisms.
To be precise about the claim: this is not a story about shipping a product alone. Two personal prototypes led to a staffed initiative that is still in development. I'm on its steering team for the WCAG and ARIA rules, the validation logic and the scope of the first release.
What travels
Most design leaders have a version of this idea sitting in a doc, waiting for a roadmap slot it will never get. The lesson isn't build it yourself instead of asking. It's narrower:
If you can't get the resources to prove an idea, make the proof cheap enough that resources stop being the blocker.
A pitch asks people to imagine. A working prototype lets them argue with it. That is a much better conversation.