We made it possible to design inside your team’s real Flutter app 🎨
A while ago, a Fortune 200 company asked us to turn Nowa into a design tool for their designers. Their Flutter teams had listed where their week went, and two things on that list will sound familiar if you design for a Flutter team.
The first is the message you send at 5:52 PM: “Tiny thing 🙏 the padding on the order card should be 4px, not 6px.”
The second is the error screen you never designed. Your file only showed the happy path, so whoever was coding at 6 PM made one up.
Both happen because you design a picture of the app, and someone else builds it again in Flutter. So we built a design tool into Nowa that works on the app itself, and you don’t need to write code. We use it ourselves to design Nowa inside Nowa.
This post shows you how it works, step by step. (If you want the gory details of why Figma and Flutter never quite match, line heights included, we wrote a whole post about the handoff.)
You can design directly in your team’s Flutter app. In Nowa, you work on the app’s real UI, by hand on a visual canvas or with your own AI agent. You check every state, play and share the prototype, and your work lands in the repo as a commit. Developers keep the logic, so you can’t break it.
We also wrote this up for the rest of your team: the guide for developers and the guide for PMs.
What you own, and what you can’t break
We built all of this around two beliefs.
First, designers should design with the material the app is made of. A Figma mock of a food app is a photo of food. It can look amazing, but nobody can taste it.
When you design in Flutter, the same technology the app runs on, you see what users see: text that wraps, layouts on actual screen sizes, the loading spinner, the motion. You make better calls because of it, and you can design whole experiences instead of single frames.
Second, designers should own the UI, all of it: the screens, the design system, the animations, and every state a screen can be in. Nothing gets rebuilt later by someone else.
To make that safe, we came up with PureUI, a way for your team to split the app in two.
The UI lives in its own package, which you own and edit in Nowa. The logic lives in the app, which developers own and build in their IDE. A small contract connects the two.

You can’t break the logic from the UI package, because it can’t reach it. And every change you make goes through the same pull request review as everyone else’s.
You don’t really need to know Dart for any of this. The canvas and your AI agent write the code, and you judge the result where it matters, on the screen. The code is there to read whenever curiosity strikes.
Your week at a glance
To show you how this works, we built Bite, a pretend food delivery app, and its order tracker: the screen you stare at while you wait for dinner. It has everything that makes UI work annoying: loads of states, a confirmation before cancelling, a courier who keeps moving, and a live map. You may get hungry.

Two people build it. Maya, the designer, works in Nowa. Omar, the developer, works in VS Code with an AI agent and the simulator, same as always. Here’s their week:

The rest of this post follows Maya’s lane, one step at a time, so you can do the same on your team’s app.
Step 1: Agree on the contract with your developer
To start a feature, sit down with your developer and answer two questions: what does this screen show, and what can the user do on it? The answers become a small contract file in the UI package. It takes about 15 minutes.
Maya and Omar do this on Monday morning, and it’s the only meeting they need to get going. (We know. At a big company, that’s the least believable sentence in this post.)
If your developer wants to see what the contract looks like in code, send them the developer’s guide.
Step 2: Set up your design system
Your brand lives in Nowa’s Themes panel. To set it up, pick your brand colors one by one, or generate them all from a single seed color. Then set the default font, the text styles, and how buttons and fields look.
Behind the panel is a regular Flutter ThemeData in the UI package, the same one the app runs with. So there’s no second library to keep in sync.
Maya tries blue as Bite’s brand color and watches every screen on the board change at once. Then Maya decides orange had more appetite and switches back. It took no ticket and no handoff.
When you pick a color for a single widget, it comes from the theme too (Theme.of(context).colorScheme.primary in the code), not a hex value someone has to hunt down later.
Step 3: Connect your own AI agent
We built an MCP server into Nowa, so you can bring the AI agent you already use instead of a built-in one. That can be Claude Code, Cursor, Codex, or any other agent that can add an MCP server by URL.
That’s good for privacy. The MCP server runs on your own machine and only accepts local connections, and your agent runs under your company’s usual AI accounts and rules.
Your agent is also already set up, with your conventions and the rest of your tools. And you don’t pay for tokens twice, once for your agent and again inside a design tool.
To connect it, open Connect External Agent in Nowa, copy the server address, then add it to your agent (step by step). It takes a minute.

Step 4: Design with the canvas and your agent
You can design visually, with AI, or both.
For hands-on changes, use Nowa’s visual canvas: move things around, tweak padding, swap a font. The canvas draws the actual widget code with Flutter, so nobody rebuilds it later.
For bigger changes, bring your agent. The trick is selection. Click a part of the UI on the canvas, then write a prompt about “this”. Your agent asks Nowa what’s selected and works on exactly that part.
Here, Maya selects the receipt card and asks Claude Code for the customer’s delivery note. You know the one: “Leave it at the door, the dog is friendly.”
The note is new data, so the agent also added an optional field for it to the contract, with a mock note for the states. Because the field is optional, the app still compiles, and Omar can hook it up to real data whenever.
Adding optional fields is the one contract change you make on your own. Renaming or removing things stays a conversation.
Motion works the same way. Maya asks the agent to fade the screen between order states instead of jumping, then hits Play to try it right away. The timing gets tuned by the person who cares about it, instead of being described in a ticket.
Step 5: Design every state on one board
This is where the error screen stops being made up at 6 PM. Every state gets designed on purpose.
To design every state, write mock data for each one in the design file that sits next to the widgets in the UI package. You (or your agent) write those mocks once. Nowa then lays all of them out on a board, our word for a canvas full of live screens.
For Bite’s tracker, that’s loading, no order, failed, placed, preparing, the cancel confirmation, on the way, delivered and cancelled. Change a widget once and every state updates, like the delivery note did:

Step 6: Play it and share it with your PM
A screenshot can’t tell you whether a flow feels right, so we made every screen on the board playable.
To try a flow, hit Play on any screen and tap through it like a hungry customer would. Maya cancels the order, confirms, watches it cancel, then reorders. A small prototype in the design file fakes the responses, so there’s no backend and no waiting on Omar.
To share it, click Share preview and drop the link in your team chat. Your PM can tap through the same prototype in a browser. Private links only open for people on the project, and sharing works for projects synced to Nowa’s cloud (more on sharing).

Step 7: Commit and push
To get your work into the repo, commit it from Nowa’s Git panel, on a branch, like everyone else on the team. Click Commit All, then Publish Branch, then open the pull request on GitHub the usual way.
Maya’s list of changes only touches the UI package.
Step 8: Pull and run the full app
Meanwhile, Omar has built the logic and pushed it.
To see your UI with the real logic, click Sync in the Git panel to pull it, then hit Run. This is the one time Nowa runs your logic.
Run builds your actual app with the normal Flutter toolchain, the same way flutter run does. On a Mac or Windows, the app shows up inside Nowa in a device frame. On Linux, where we recorded this, it opens in the browser.
Now Omar’s logic is driving. The order moves from preparing to on the way by itself, the courier crawls across the map, and the delivery note on the receipt comes from the order instead of a mock.
And Maya isn’t done. On Thursday, the status icon looks too small, so Maya changes it and commits it. Omar isn’t blocked and doesn’t need to know until the pull request shows up.
What changes for you
You design each screen once, in the material the app is made of. Every state gets designed instead of made up at 6 PM. And your padding fixes become commits instead of messages to a developer.
Here’s the whole product in about a minute 👇
If you’d like to see it on your team’s own app, I’d love to show you.
See Nowa for Flutter teams →
Happy building all!
Anas



