← Back to Blog
Product

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

Anas Alsalhi · 7 min read

We let designers and developers build the same feature side by side 🤝

A while ago, a Fortune 200 company asked us to turn Nowa into a design tool for their designers. Their Flutter teams had looked at where the week went, and the answer hurt.

About half of what their designers and developers did felt like waste: handoffs, back-and-forth, and building the same screen twice. That half is time your roadmap doesn’t get.

So we built a way for both sides to work on the same feature at the same time, in the same Flutter code. This guide shows where the week goes, how it runs instead, and what you get to review along the way.

The short answer

Design and development lose time when they work one after the other, on two copies of the app. Instead, your designer and developer agree on a small contract for each screen in a 15-minute meeting. Then designers build the real UI while developers build the logic, at the same time, in the same Flutter code. You review the actual app, not screenshots.

We also wrote guides for the rest of your team: Flutter for Designers for designers, and the PureUI architecture for developers.

Where half the week goes

This is the list their teams shared with us. If you’ve worked with a Flutter team, you could have written it:

  • A designer sends “Tiny thing 🙏 the padding on the order card should be 4px, not 6px.” It lands at 5:52 PM, and the dev fixes it. Two days later it’s still 6px, because there were two order cards and the dev fixed the other one.
  • The designer opens the new build, compares it to Figma pixel by pixel and files tickets. The dev fixes the tickets. Repeat until someone gives up.
  • The designer builds the screen in Figma. Then a developer builds the exact same screen again in Flutter.
  • Figma shows the happy path. Loading, empty and “something went wrong” get designed by whoever happens to be coding at 6 PM.
  • Colors and text styles live in a Figma library and again in a ThemeData. They drift a little further apart every sprint.
  • The Figma file says one thing, the code says another, and keeping them in sync is a job nobody signed up for.

None of this is anyone’s fault. The designer works on a picture of the app, the developer works on the app, and every trip between the two loses something. (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.)

How the week runs instead

Our answer was to let designers work on the real Flutter app while developers keep the logic. We built an architecture for it called PureUI, which splits the app in two. Designers own everything people see, developers own everything it does, and a small contract per screen connects them.

To show you how it works, we built Bite, a pretend food delivery app. Here’s one feature, start to finish: its order tracker. Maya, the designer, works in Nowa. Omar, the developer, works in VS Code.

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.

On Monday morning, Maya and Omar sit down together for 15 minutes and answer two questions: what does this screen show, and what can the user do on it? The answers become the contract.

That’s the only meeting they need to get going. (We know. At a big company, that’s the least believable sentence in this post.)

For the rest of the week, they work side by side. Maya sets up the theme, designs the screens and the motion, and checks every state. Omar maps the backend’s data, wires up state and actions, and writes tests. Both push to the same repo.

We built this around two beliefs. First, nobody should wait for anybody. Designers shouldn’t wait for a build to see their work, and developers shouldn’t wait for a final design to start.

Second, the repo should be the only source of truth. There’s no design file to keep in sync, because the UI the designer works on is the UI that ships.

What you get to see, and when

You review the real thing at every stage instead of a picture of it.

You see every state before the backend exists. Each state of a screen gets mock data and shows up on one board: loading, no order, failed, placed, preparing, on the way, delivered, cancelled and the cancel confirmation. So you see the error screen before it ships, not after.

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

You get a prototype link you can tap through. When a flow feels right, the designer shares a preview link in the team chat. Open it in your browser and tap through the same prototype, built from the real widgets. Private links only open for people on the project.

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

You get the full app, with real data. Once both sides have pushed, anyone can pull and run the actual app. The order moves from preparing to on the way by itself, the courier crawls across the map, and the data comes from the backend instead of mocks.

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

And you get late changes without tickets. 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 the team

Back to the list from the beginning. Here’s what each item turns into:

What used to eat the weekWith Nowa and PureUI
Ping-pong over padding and colorsThe designer changes the UI and commits it
Design reviews against FigmaEveryone reviews the actual thing: a shared preview or the running app
Building every screen twiceThe designer builds it once, in Flutter
States improvised at 6 PMEvery state has mock data and gets designed
A Figma library and a ThemeDataOne theme, in code
Two sources of truthOne: your repo

How to try it on one feature

To try it, pick the screen your team rebuilds most and build that one feature this way. You don’t need to change the whole team at once.

Measure two things before and after: how many review rounds a screen takes, and how many days pass from design to merged code.

If you stop, you still keep a cleaner, well-tested feature. If it sticks, nobody on your team gets a padding message at 5:52 PM again.

What’s coming next

We’re not done. Here are two things we’re building now:

  • Live collaboration Soon will let designers, developers and PMs work in the same project at the same time.
  • Comments your agent can act on Soon will let you pin comments on any part of the canvas during a review. Then you hand them all to your AI agent, and it works through every one of them in one go.

See it in a minute

Here’s the whole product in about a minute 👇

We run our own team this way too. Here’s how we design Nowa inside Nowa.

If you’d like to see it with your team, I’d love to show you.

See Nowa for Flutter teams →

Happy building all!
Anas

Keep reading

Product

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

We made it possible to design in your team's real Flutter app. Step by step: set the theme, design with your AI agent, check every state, share and commit.

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.