← Back to Blog
Product

Flutter for Designers: Design the Real App, Not a Mockup

Anas Alsalhi · 10 min read

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.)

The short answer

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.

The app split in two: the UI package, owned by designers and edited in Nowa, holds the widgets, the design system, mock data for every state and clickable prototypes. The app, owned by developers and built in their IDE, holds state management, APIs and tests. The contract between them carries data into the UI and the user's actions back to the app.

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.

The Bite order tracker on a board in Nowa: the same widget rendered as nine phone screens, from loading and failed to on the way, delivered and cancelled, each fed different mock data

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 week at a glance: Maya and Omar agree on the contract together. Then Maya's lane in Nowa (set up the design system, design screens with the visual canvas and their own AI agent, check every state, play and share the prototype, commit and push) and Omar's lane in the IDE (map data, wire state and actions, write tests, commit and push) run in parallel and meet at Pull and Run the full app. Either side keeps iterating, and nobody waits.

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.

One seed color in the Themes panel, nine screens recolored. The short wait is sped up.

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.

Nowa's Connect External Agent dialog: the MCP server URL, with its access token hidden here, and a ready-made Claude Code command

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.”

Maya selects the receipt card on the board, then asks Claude Code (right) for the delivery note. The agent works through Nowa’s MCP server, and the note appears on the canvas live. The agent’s thinking time is sped up 3x.

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.

The crossfade Maya asked for, running in Play: Cancel order, then Reorder.

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:

The board in Nowa after the change: the on the way, cancelled and delivered screens and the receipt card all show the new delivery note, from one mock

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.

Play runs the prototype on mock data. No backend involved.

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).

Nowa's Share Preview dialog with the private option selected, next to the shared link open in a browser, where the prototype runs on its own

The shared preview (right) plays the same prototype in a browser. We hid the project ID in the link.

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.

A new branch, three changed files in the UI package, Commit All, Publish Branch. Typing is sped up.

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.

Sync pulls Omar’s commit, Run starts the full app, and the order plays out with real logic. Waiting is sped up.

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

Keep reading

Product

Designer-Developer Collaboration in Flutter: A PM's Guide

Where your Flutter team's week goes between design and development, and how we let both sides work in parallel after a 15-minute contract.

Product

How We Design Nowa Inside Nowa

We're designing Nowa inside Nowa itself, and it made us ship almost 10x faster. Here's how our designers and developers build each feature in parallel, on one Flutter codebase.

Product

Figma to Flutter: Stop Building the UI Twice

Every Figma to Flutter handoff builds the UI twice. We built a way for designers to edit the real Flutter app while developers build the logic in parallel.