A lot of companies treat design like painting a house. You hire a designer, they make it look good, you hand the files to developers and the designer moves on. Design becomes a phase on a Gantt chart: two weeks between "requirements" and "development".
The trouble is that products aren't houses. They change every sprint, users behave in ways nobody predicted, and the screens that looked perfect in Figma meet real phones, real networks and real people. When design leaves the room after the "design phase", those surprises get solved by whoever is nearest, usually without research, consistency or a clear view of the user.
I've worked on products from first sketch to shipped build, and the biggest lesson I've taken from them is simple: design works best as a constant, not a phase. Here's what that means in practice, and how to set it up.
What "design as a phase" costs you
When design is a single block of time, a few predictable problems show up.
- Decisions get made without design. A developer hits an edge case the mockups didn't cover and invents a solution on the spot. Multiply that by a hundred and the product drifts away from the design.
- Inconsistency creeps in. New features borrow bits from old screens, spacing and colours vary, and the interface slowly feels patched together.
- Learning stops at launch. Nobody watches how real users behave, so the same friction stays in the product for months.
- Redesigns become expensive. Instead of small, regular improvements, you end up with a big, risky rebuild every few years.
That last one is common in older products. When I worked on Demerara Bank, the existing system couldn't scale to a modern interface, and customers had to visit a branch for routine tasks. One customer said the old app looked so dated they didn't fully trust it with big transfers. That's the bill for years without continuous design attention.
| Design as a phase | Design as a constant | |
|---|---|---|
| Edge cases | Developer guesses | Designer answers in the sprint |
| Consistency | Drifts with every feature | Held by a maintained design system |
| After launch | Nobody watches real use | Regular reviews and small fixes |
| Big changes | Risky rebuild every few years | Steady, smaller improvements |
What "design as a constant" looks like
Design as a constant doesn't mean a designer in every meeting forever. It means design thinking is present at each stage, with the right level of effort.
Before building: research and strategy
This is where I start every project, away from Figma. Understand the users, the problem and the business before drawing anything. On Pukaar.ai, that meant 70+ user interviews, a community of 400+ parents and real 2 a.m. questions from a WhatsApp channel before the key flows took shape. Everything after that rests on this groundwork.
While building: design alongside development
At Ksolves, I prepare developer handoff in Figma Dev Mode within Agile sprints, which means I'm around while things are being built. That matters, because questions come up daily: what happens when this text is longer, what does the empty state look like, how should this animate. A designer who is available answers them in minutes. One who has moved on leaves developers guessing.
Tip
Keep a shared "design questions" thread for each sprint. Developers drop edge cases there as they hit them, and the designer clears it once a day, so nothing gets decided silently.
After launch: measure, learn and refine
Launch is the start of the most valuable design phase, not the end. Real usage shows what research couldn't. Pukaar went from zero to live in 15 weeks, and now that it's on Google Play and the App Store, there's a clear list of what I'd design next: showing the top two cry reasons with confidence, starting the listening right away with a live waveform instead of a 10-second wait, and letting parents try a cry analysis as a guest before signing up. Those ideas only exist because the product is in people's hands.
The design system is what makes constant design possible
You can't keep design involved in every sprint if every new screen starts from scratch. A design system is the infrastructure that lets design scale without a designer drawing every pixel.
On Demerara Bank, we designed a new mobile app (38 screens in 4 weeks) and a web banking revamp (24 screens in 3 weeks) on one shared, scalable design system. The biggest product goal was "one login, one system": one mental model across web and mobile. A shared system meant new screens could be added later without breaking that consistency.
At Ksolves, I build and maintain a design system and component library with Auto Layout, components and variants. Maintenance is the important word. A design system isn't a deliverable you finish; it's a living product that needs an owner. If you're a small team, start smaller than you think.
Watch out
A design system with no named owner goes stale within a few sprints. Developers stop trusting it and start copying old screens instead.
How to set it up, depending on your team
You don't need a large design team to make design constant. Here's what I'd recommend at different stages.
Early-stage startup
- Bring a designer in before the first line of code, even for a short research sprint.
- Agree on a small set of core components early.
- Keep the designer involved part-time after launch to review new features and look at user feedback.
Growing product team
- Include design in sprint planning and reviews, not only kick-offs.
- Give someone clear ownership of the design system.
- Run small usability tests regularly, even with five users, rather than one big study a year.
Working with an outside designer or consultant
- Scope for ongoing support after handoff, not just the initial screens.
- Schedule a post-launch review once real usage data exists.
- Ask for documentation of key decisions so the reasoning outlives the engagement. I cover scoping in more detail in working as a design consultant.
How to know it's working
Constant design should show up in results, not just process. Track a few simple signals:
- Task completion on the core flows
- Support queries about things the interface should make obvious
- Consistency issues found in design QA each sprint
- User trust and satisfaction, from reviews, surveys or interviews
On Demerara Bank, the reported impact after the redesign included a 60% increase in task completion and a 35% reduction in support queries. Numbers like these are easier to keep improving when someone is still looking after the design. For more on choosing the right numbers, see measuring UX impact.
Note
Pick your signals before a change ships and record the starting value. Without a baseline, "it feels better" is the only result you can claim.
Key takeaways
- Treating design as a phase leaves developers guessing and lets products drift.
- Design should be present before, during and after building, at different levels of effort.
- Launch is when the most useful design learning begins.
- A maintained design system is what makes constant design scalable.
- Measure task completion, support load and trust to show the value.
Keep design in the room
The products I'm proudest of weren't designed in one heroic burst. They got better because design stayed involved: researching, answering questions during development and refining after launch. If you're a founder or product lead, the cheapest improvement you can make is often just keeping your designer in the room a little longer.
See how this played out in the Pukaar.ai and Demerara Bank case studies. If you'd like design as a constant on your product, let's talk.
Work with us
Ready to hire? See how to hire a UI/UX designer from our studio, project-based or as a dedicated designer.