Article · Choco
From demo to dogfooding
How design, engineering and QA worked together at Choco to ship with confidence.
At Choco, our design process was built around collaboration, technical feasibility and continuous user feedback. To get from concept to implementation without losing anything on the way, we structured it around three things: design demos and feedback sessions, user testing reports, and QA with dogfooding. Together they closed the gap between design, engineering and product strategy, and made sure real users validated what we built.
Design demos and feedback sessions
Purpose
Demos are a structured space for engineers, designers and product managers to align on the product vision and on technical feasibility. Discussing prototypes, wireframes and flows early lets the team solve problems before development starts, not after.
How it works
1. Every session is recorded and stored. All demos are recorded and logged in a table. If someone misses a session, or an engineer joins mid-project, they watch the recording before asking a designer for context. No unnecessary time travel.
2. Silent critique. The designer presents a flow or a specific user problem and walks through it step by step, so the problem, the solution and the context are clear. Feedback is written in silence, so everyone has time to think without interruptions.
3. Clarifications first, discussion last. Questions about anything unclear come before feedback. Open discussion happens only after all feedback has been collected.
4. Not comfortable speaking? No problem. People who prefer to observe can turn their camera off, as long as they give written feedback. The point is clear, structured feedback, not forced participation.
5. Repeat until it's clear. If something isn't fully understood, we go through it again. No assumptions, only alignment before moving on.
Tying it together
Every session is logged in a demo tracker that records who ran it, when, the topic and the key decisions. It is the single source of truth for design decisions. Demos are also linked to the PRDs, so decisions can be traced back to the roadmap and requirements. No more digging through Slack threads or old Figma comments.
What it gives the team
- Engineers see prototypes early and shape the implementation: feasibility, scalability, code reuse.
- Designers get technical insight that sharpens their work and smooths the handoff.
- Product managers keep design, engineering and business goals aligned.
- Stakeholders can follow progress and see how decisions support the strategy.
Code ready designs, with specs, components and documentation, make the move from design to development smooth. The result is less misalignment, less technical debt and a faster cycle.
User testing reports
To validate designs against real needs, we tested with Maze and Figma. People worked through early prototypes, we collected their behavior and feedback, and we iterated.
- Maze tests show usability problems, pain points and behavior patterns.
- Figma is where we discuss the findings, right next to the designs they refer to.
- A caveat: these tools don't fully replicate the live product, so results need careful interpretation.
We tested with three groups, each with its own strengths:
- Choco customers. The most relevant insights, but slow to respond, and focused on finishing the task rather than writing feedback.
- Employees. Valuable feedback, but they sometimes drift from the tasks or treat the test as a demo.
- A hired Maze panel. Fast, often within the hour, but some testers click randomly to get through, so results need filtering.
Combining the three gave us real world feedback and fast iteration at the same time.
QA and dogfooding: making sure it works before it ships
Alignment between design and engineering is only the beginning. Before anything went live, every squad member took part in a QA session. Not to check whether it looks right or technically works, but whether it actually works for real people.
By that point the team had already documented the business context and limitations, refined the design through user testing, and agreed on feasibility with engineering. The last step was to put ourselves in our users' shoes and catch problems before they did.
How we ran QA sessions
1. Everyone participates. QA isn't only for testers. Designers, engineers and PMs all test the feature, each from their own area of expertise.
2. Structured testing, not clicking around. Each session follows a script. Does the feature behave as expected? Can people complete the key actions without confusion? Which edge cases could break the flow? Bugs, inconsistencies and UX friction are written down immediately.
3. Real devices, real environments. We test across devices, browsers and scenarios. Mobile features are tested on real phones, not only in a simulator. Critical flows are tested under real constraints: slow internet, small screens, accessibility needs.
4. Dogfooding: eat what we cook. Whenever possible, we use the feature ourselves before release. For an ordering platform, we place real test orders. For a messaging feature, we communicate through it for a day. If something feels off to us, it will feel ten times worse to our users.
5. Repeat until it's solid. If we find major issues, we fix them before release, and repeat QA until the feature is functional, easy to use and resilient.
Why this matters
QA isn't a checkbox. It's the last line of defense before people use the product. Making it a team wide effort means no blind spots, and what we ship isn't just functional, but usable, scalable and reliable.
If we wouldn't use it ourselves, why would we expect our users to?