Noon just raised $44M to eliminate the gap between design and code. Here's what they're actually proposing — and why it matters more than the headline suggests.
There's a ritual I've watched play out in design reviews. Someone shares their screen. A Figma file opens. Twenty minutes get spent debating whether a modal should slide in from the right or fade up from the bottom. Then someone asks, "but how will this actually work when the data loads slowly?" and the designer says they'll figure it out in the next iteration. The meeting ends. The engineers look at the spec. They make a decision. The designer finds out three weeks later.
I am not exaggerating. That is the handoff ritual, and it has survived Zeplin, InVision, Figma's Dev Mode, and about forty other tools that promised to fix it.
Earlier this month, a startup called Noon came out of stealth with $44 million in funding and a pitch that sounds like marketing copy until you read it twice: "What goes on the canvas isn't a picture of a product. It is the product."
I've heard versions of this before. But Noon is describing something structurally different, and it's worth thinking through what it actually means.
What Noon Is Doing
Noon is what they're calling a "dual-canvas" design tool. You design on top of your team's actual codebase and design system, not a representation of it. The components you place on the canvas aren't static assets — they're real UI components from your production repository. When you define an interaction, you're defining behavior in code. There's no handoff step because there's no gap to cross.
The distinction from Figma's recent moves is significant. Figma added Git integration and live code sync at Config 2025, which means design files can now branch and merge alongside production code. That's useful infrastructure, but it's still a picture of a product syncing to code. Noon is proposing you skip the picture entirely.
Claude Design, which Anthropic launched on April 17, is solving a different problem. It generates functional HTML prototypes from text prompts, which is impressive and genuinely useful for communication. But it's a generation tool. Noon is a design environment that lives inside an existing production system.
The backing tells you who the market is: heads of design from Stripe, OpenAI, Apple, Meta, and Shopify. These are people who run design orgs at companies with mature design systems and large engineering teams. They're not investing in a Figma replacement for early-stage teams. They're investing in something that solves a specific, well-understood problem: the cost of the prototype-to-production gap at scale.
What goes on the canvas isn't a picture of a product. It is the product.
— Noon
What That Gap Actually Costs
If you've never had to explain to a PM why a feature that looked done in Figma will take two more weeks to actually be done, you may not feel the weight of this. But the gap is real and it compounds.
A designer mocks up a component. An engineer implements it. The implementation reveals edge cases the mockup didn't account for. The designer needs to update the mockup. Now the mockup and the implementation are out of sync, which means the next round of design review is reviewing an artifact that doesn't represent reality. Everyone in the room knows this. No one says it out loud. The meeting continues.
The gap isn't a workflow problem. It's a representation problem. Figma files are representations of products, and representations accumulate drift. The further a team gets into a product cycle, the more the Figma file becomes archaeology rather than documentation.
Noon's claim is that if the canvas is the code, there is no representation to drift. The design review is reviewing the product.
The Thing Worth Getting Worried About
Here is where I want to be precise, because the obvious response to Noon is "great, so designers are out of a job," and that's the wrong read.
The work that Noon makes obsolete is not design. It's a specific artifact: the high-fidelity mockup of a thing that will be rebuilt by an engineer anyway. That artifact has always been a proxy. It's not the place where the design actually happens. The design happens when you figure out what the product should be, what the interaction model is, what the mental model of the user requires, and how to reconcile those things with technical constraints and business priorities. None of that is in the Figma file. The Figma file is the output of that thinking, and it's been standing in for the thinking in too many organizations for too long.
What changes with Noon is that the feedback loop gets shorter. Instead of designing a flow, handing it off, waiting for implementation, and then discovering problems, you can discover the problems while you're designing. That is genuinely useful. A designer working in Noon can see immediately when a component doesn't exist in the design system, when a layout breaks at the edge case viewport, when a state transition requires logic that contradicts the product model.
But shorter feedback loops only help if you know what you're looking for. And knowing what you're looking for is the skill. It requires understanding users deeply enough to know what matters, understanding the system well enough to recognize when something is structurally wrong, and having enough seniority to advocate for the right solution when the fast solution is available.
Tools like Noon raise the floor. Anyone with access to the codebase can now produce a functional prototype quickly. That is real and it matters. It does not touch the ceiling. The ceiling is still: what should this product be, and why, and how do you know?
What to Actually Watch
The shift I'm watching isn't Noon vs. Figma. It's what happens to design reviews when the artifact is live.
Right now, design reviews have a built-in buffer. The mockup isn't real, so decisions made in the review are decisions about intent, not about execution. There's room for interpretation. Engineers interpret the spec. Designers revisit decisions when they see the build. It's inefficient, but it's also a space where things can change.
If the canvas is the product, design review becomes something closer to a code review. Changes have immediate consequences. The conversation shifts from "is this the right direction" to "this specific implementation is wrong for this specific reason." That's a more rigorous conversation. It also requires a different kind of designer — one who can operate fluently in the medium of production software rather than the medium of design files.
The designers who should be paying close attention to Noon are not the ones worried about their jobs. It's the ones who are relieved that their job has finally gotten more precise.
One More Thing
Noon raised $44 million at seed, which is described as the largest stealth funding round for a design-technology startup. That's a specific signal. It means investors believe the category is real and that Noon's approach is defensible. It also means the pressure on Figma to move faster is genuine.
Figma's competitive response so far has been infrastructure: Git integration, AI-generated tokens, Dev Mode improvements. These are the right moves but they're incremental moves. They're making the representation-to-code pipeline better. Noon is proposing to remove the pipeline.
Whether Noon's approach works at scale — for teams that don't have perfectly structured codebases and clean design systems — is an open question. Most real products are not Stripe. Most design systems are partially documented, partially enforced, and partially a wishful fiction. How Noon handles that reality will determine whether it becomes the standard or a premium tool for a narrow tier of well-resourced teams.
Either way, the category it's naming is real. The gap between design and code has always been where design value leaked out. The tools are finally starting to take that seriously.