Flutter Development Field Notes from a SaaS Product Team
I spent the first half of 2025 leading a Flutter development effort for myQRCode, a dynamic QR code studio used by teams in over 40 countries. The product was already live, but the mobile app needed a rebuild, and I was asked to step in as the technical lead. What I learned in those months changed how I think about technical leadership in a product company. Not because the framework was hard, but because the team, the scope, and the market all pulled in different directions at once.
Flutter development forced me to rethink code review
My first instinct was to treat code review as a gate. A senior engineer looks at a pull request, approves it, and the code ships. That works when everyone on the team has the same mental model. It fails when two junior engineers are writing Flutter widgets for the first time and a designer in Berlin keeps sending Figma files with iOS-specific spacing.
So I changed the process. Instead of reviewing code after it was written, I sat with the juniors before they wrote a line. We sketched widget trees on a whiteboard, or in a shared document, and argued about state management choices. Then they coded. The review became a check against the design we had already agreed on, not a surprise inspection. One engineer, fresh out of a bootcamp, stopped asking me to fix his layout and started asking why a ListView rebuilds on every scroll. That is when I knew the review was working.
I did the same with design sessions. The myQRCode app needed a QR scanner, a generator, and a dashboard for saved codes. We broke each feature into small, reusable widgets before touching the codebase. That forced the juniors to think in composition, not screens. It also meant the senior reviews were shorter, because the hard decisions had already been made together.
Sprint management with a distributed team means writing things down
We ran two-week sprints with a team spread across Douala, Berlin, and a contractor in London. Daily standups happened over text, not video, because time zones did not overlap by more than two hours. The first sprint was a mess. Tickets said things like "improve scanner performance" and nobody knew what done meant.
I rewrote every ticket with acceptance criteria. A ticket for the QR generator became: "User taps Generate, enters a URL, and gets a PNG download in under two seconds. The PNG must be scannable by the iOS camera from 30 cm." That level of detail felt bureaucratic at first, but it removed the daily back-and-forth. The juniors stopped guessing and started shipping.
We also cut sprint length to one week after the third sprint. Two weeks was too long for a product that changed direction every time the client saw a demo. One week forced us to break work into chunks small enough to demo on Friday. It also exposed scope creep faster. When the client asked for a custom QR frame feature mid-sprint, I could point to the board and say, "That lands next week, not this one." The same discipline applied to Workbud, a workshift platform I led later. Distributed teams need written agreements, not verbal promises.
Scope alignment is a daily negotiation, not a quarterly event
Product managers want features. Designers want polish. Clients want everything yesterday. As the technical lead, my job was to keep all three honest without becoming a bottleneck. I did that by showing up to every design review and every client call, even when I had nothing to say about the business logic.
In Flutter development, the tension shows up in platform expectations. A designer sends a mockup with a bottom sheet that slides over a map. On Android, that is a standard pattern. On iOS, the same interaction feels wrong because the platform uses modals differently. I had to explain that cross platform consistency matters more than pixel-perfect fidelity. The client did not care about the framework, but they did care that the app felt native on both stores. So we compromised: a bottom sheet on Android, a modal on iOS, and a shared state layer underneath.
That negotiation happened every day, not once a quarter. I learned to write down the decision, the reason, and the person who signed off. When the client came back two weeks later asking why the iOS version looked different, I had the note. That is what fractional CTO work really is: keeping a paper trail of scope decisions so the team can move without re-litigating the past.
What I got wrong and fixed mid-flight
I underestimated camera permissions. The QR scanner worked on my test device, but a beta tester in Switzerland reported a black screen on Android 14. The permission flow had changed, and our code assumed the old model. It took two days to fix, and it delayed the beta by a week. I should have tested on a wider range of devices earlier.
I also let the team merge without a linting step for the first month. Merge conflicts ate half a day every sprint, mostly because two engineers formatted the same file differently. I added a pre-commit hook and a code owners file, and the conflicts dropped to near zero. The juniors grumbled at first, but they stopped grumbling when they saw how much time they got back.
These mistakes were not fatal, but they were avoidable. The lesson I took away is that technical leadership in a product team is not about knowing every API. It is about setting up guardrails before the team needs them, and admitting when you missed one.
The SaaS sector pattern I trust for technical leadership
SaaS products reward small, frequent releases. A QR code studio does not need a six-month roadmap. It needs a scanner that works, a generator that exports clean PNGs, and a dashboard that loads fast. Everything else is noise. So the leadership pattern I trust now is this: review relentlessly, write everything down, negotiate scope daily, and ship something every week.
That pattern held for myQRCode and it held for Workbud. Both products shipped to real users in multiple countries, and both kept shipping after I stepped back. That is the test of technical leadership: does the team keep moving when you are not in the room? In my experience, the answer depends on how well you mentored the juniors, how clearly you wrote the tickets, and how honestly you aligned scope with the people paying for the work.
If you want to see how these patterns held up under real deadlines, start with the SaaS case studies. The proof is in the details, not in my summary.
Want to talk about something here?
Let’s talk about it.