Built from trial, scope creep, and “we thought that was included…”

I didn’t land on this process overnight. Like most designers, I learned the hard way—through messy projects, vague feedback, misaligned expectations, and those dreaded last-minute “we assumed that was included” emails.

Over time, I’ve refined this workflow not just to run smoother, but to create clarity—for clients, stakeholders, and my team. Whether I’m running point on a freelance project or navigating the constraints of an in-house process, this structure helps me lead, collaborate, and protect the work.

It’s not about control. It’s about alignment. And when the process is clear, outcomes are better, timelines are healthier, and client relationships feel strong instead of strained.

1. Discovery

If you’re a department lead or project manager, here’s something worth hearing: designers need to be involved in discovery. Not just copied on briefs afterward. Not brought in once the client has already made requests about colors and animations. Brought in early—while strategy is still being shaped.

Why? Because designers translate business goals into real-world experiences. We identify friction, uncover mismatches between what users want and what the business is saying, and connect dots that shape better outcomes. But we can’t do any of that without early context.

When I lead discovery, I guide clients toward clarity. We talk outcomes before features, like “increase mobile form conversions” instead of “add a sticky button.” I’ll often include a competitor audit or teardown of their current site, then explain my insights in a Loom video so the thinking is as clear as the findings.

If you’re a designer and you’re not looped into discovery, don’t wait for an invite. Ask for access to the strategy notes. Better yet, suggest joining a quick insights review. When you position it as a way to reduce revisions and improve handoff speed, decision-makers usually listen.

Discovery success checklist:

• Focus on business problems, not just aesthetics
• Ask outcome-driven questions early
• Use visual aids and Loom walkthroughs to explain your insights
• If you lead teams: invite designers into early discovery calls
• If you’re on a team: advocate for access to insights before the design phase

My go-to tools:

• Notion or Google Docs for guided intake
• Loom for async walkthroughs
• Relume for early sitemap and content mapping

2. Planning

Planning defines the structure of the work—what’s included, how it fits together, and what success actually looks like. This is where scope creep either gets blocked or sneaks in quietly.

When I’m running the show, I use a sitemap and flowchart (usually in Relume) to lock in page types, template count, and content expectations. Everything new that comes up during planning—those “oh, we forgot to mention…” moments—gets logged into a future phase, not quietly absorbed.

Inside an agency, though, planning can feel less structured. Designers often inherit a brief without clarity on templates, features, or content requirements. If that’s the case, don’t wait for someone to fix it. Build your own working doc. List out what you think is in scope, ask questions, and get signoff. This one step can prevent days of redesign and missed expectations later.

And if these gaps keep showing up across multiple projects, suggest a simple retro. A 15-minute workflow chat can be all it takes to start solving a systemic issue—especially when framed as “Here’s one thing that could help us move faster next time.”

Planning essentials:

• Confirm page types, templates, and features in writing
• Visualize user journeys or content flows to get approval
• Log all new ideas in a Phase 2 doc
• If you lead: set expectations clearly and early
• If you’re on a team: document your assumptions and raise questions early
• If inefficiencies repeat: propose a small process improvement or retro

My go-to tools:

• Relume for sitemaps and flows
• Notion or ClickUp for deliverable tracking
• Dubsado or Bonsai for formal scope documentation

3. Design

Design is where energy spikes and opinions multiply. This is the phase where clarity matters most—because it’s easy for clients (or internal teams) to misinterpret what they’re seeing if the process isn’t clearly outlined.

I split design into three stages:

• Wireframes to nail structure and layout without visual distractions
• High-fidelity mockups for branding, typography, and visual design
• Interactive prototypes to simulate real user flow and validate interaction

Each stage builds on the last. I don’t move to high-fidelity until the wireframes are approved, and I don’t prototype until the visuals are locked. This sequencing avoids redundant rounds and protects the project timeline.

When I freelance, I guide the client through each stage with Looms or quick check-ins, and I limit revisions to one round per stage plus a polish pass. Clear feedback deadlines keep things moving and reduce “endless edit” energy.

Inside an agency, designers don’t always get to present their work—so I prep everything to speak clearly on its own. I organize Figma files cleanly, annotate key decisions, and hand off with presentation-ready polish.

And if feedback starts to blur boundaries? I point back to the process: “We’ve moved past the layout phase, but I’ve added that note to our next-phase doc.”

Design process highlights:

• Separate layout from visuals to avoid distraction
• Guide feedback with clear prompts and deadlines
• Limit each stage to one round of structured revisions
• When freelancing: present each stage and protect feedback windows
• Inside teams: organize work to stand on its own if you’re not in the room

My go-to tools:

• Figma for layout, components, and prototypes
• Loom for walkthroughs
• Figma comments or Marker.io for structured feedback

4. Development

Once the designs are approved, development begins. But here’s where I draw a firm line: I don’t give clients access to staging. Not because I’m hiding anything—but because early-stage environments are messy. Clients often respond emotionally to half-built pages, missing content, or in-progress features, which leads to confusion and erodes trust.

Instead, I provide milestone walkthroughs. Short Loom videos or guided screenshots show what’s working, what’s pending, and where we are in the build. This keeps the client informed without letting them peek behind the curtain too soon.

As a freelancer, I scope development tightly. X pages, 1 blog template, 1 form, specific animations, and responsive behavior. Anything outside that? Logged for the next phase.

Inside an agency, designers often hand off to dev with little visibility afterward. If that’s your setup, advocate to be part of the QA loop. A quick review of how your design was implemented can catch styling mismatches or UX gaps before the client notices.

How I handle dev without the drama:

• Never give clients raw staging access—show progress through walkthroughs
• Stick to scoped features and page templates
• Log unexpected requests for post-launch
• In solo projects: outline the dev structure clearly in your scope
• In agency life: ask to be looped into dev QA or review cycles

My go-to tools:

• WordPress, Webflow, or Framer depending on the project
• Bugherd for visual bug reporting
• Loom or screenshots for progress updates

5. Testing

Testing is not a courtesy—it’s a critical step that saves time, money, and reputation. I treat it like its own phase, with space for both internal QA and client review.

I run through functionality, responsive behavior, form validation, and browser compatibility. I also flag accessibility issues and loading performance where it matters. For the client, I create a simple UAT (User Acceptance Testing) checklist that walks them through what to test and how to give feedback.

When issues come up—and they will—I use Bugherd to collect, organize, and assign fixes. And when “Can we also add…” shows up in testing feedback? I gently remind the client that this phase is for validating what we built, not adding new ideas.

Inside agencies, QA might be someone else’s job. Still, I encourage designers to peek at the build before it launches. Catching design mismatches or interaction bugs is always better before the client sees them.

Testing that works:

• Plan for both internal QA and external UAT
• Provide a checklist to guide client testing
• Use bug tracking software to stay organized
• As a freelancer: flag the difference between bugs and new requests
• As a team designer: ask to review staging to spot issues early

My go-to tools:

• BrowserStack for device testing
• Bugherd for client-friendly bug capture
• Google Sheets or Trello for internal QA tracking

6. Pre-Launch

Pre-launch is where final polish meets final pressure. Content must be in. Forms tested. Analytics connected. And this is where a firm cutoff is key—because small, last-minute edits can balloon into launch delays fast.

For freelance builds, I set a hard deadline for final content and approve-by dates. If anything slides past that, it goes live later or waits for post-launch edits. I also use a formal launch checklist that includes SEO checks, tracking setup, and performance tools.

At an agency, the launch might be handled by a dev team or project manager—but I stay involved. I prep final graphics, double-check layouts, and confirm any last design tweaks didn’t get lost in handoff. Even if launch isn’t my job, I treat it like a shared responsibility.

Pre-launch safeguards:

• Set a “last call” for edits and approvals
• Confirm content, SEO, tracking, and backups
• Define what counts as launch-critical vs. post-launch
• As a solo lead: manage this like a flight checklist
• In teams: clarify ownership and backstop your section

My go-to tools:

• Notion or ClickUp for launch checklists
• Google Calendar to time the release
• UptimeRobot or Cloudflare for monitoring uptime

7. Launch

Launch day is exciting, but fragile. This isn’t the time for new ideas or design pivots—it’s about stability. I stay present, test key actions in real-time, and make myself available for any urgent issues.

As a freelancer, I send a “We’re live!” email with next steps, a recap of what was delivered, and a reminder that changes from here are part of a new phase or maintenance plan.

Inside an agency, I stay close to the dev team and client communication loop. I check for visual inconsistencies, broken links, or form behavior—so we stay ahead of client emails that start with “Hey, something’s weird.”

A clean, calm launch:

• Monitor form submissions and speed
• Send a recap that frames next steps and boundaries
• Handle bugs fast, but log new features for later
• When freelancing: celebrate the launch and set expectations for what’s next
• On a team: stay present and act as a visual QA buffer

My go-to tools:

• WP Migrate or native CMS deploy tools
• UptimeRobot for live monitoring
• Slack or email check-ins for real-time response

8. Post-Launch

Just because the site is live doesn’t mean the work is done. Post-launch is where feedback comes in, data begins to speak, and iteration starts to take shape.

I schedule a follow-up 2–4 weeks after launch to review analytics, performance, and early behavior patterns. I also ask for client reflections—what’s working, what’s unclear, and what they wish we’d done.

This is the perfect time to introduce new ideas. A/B test that CTA. Revisit a form flow. Add a blog layout. These aren’t revisions—they’re growth strategies.

As a freelancer, this is how I turn single projects into ongoing retainers or Phase 2 builds. Inside a team, I use this moment to capture lessons learned and bring them into the next project. This is where design maturity lives—being willing to evolve.

What makes post-launch matter:

• Review traffic, conversions, and user behavior after 2–4 weeks
• Ask for feedback and gather “nice to haves” for future planning
• Use data to propose smart, strategic improvements
• As a freelancer: pitch ongoing support or optimization
• As a team designer: bring feedback back to the process

My go-to tools:

• GA4, Hotjar, or Microsoft Clarity for analytics
• Notion or Trello for road-mapping future work
• Loom or live review meetings for check-ins

Final Thoughts

This workflow was shaped by experience—by the messes, the missed steps, and the lessons learned under pressure. It’s built to give designers more clarity, clients more confidence, and teams more structure to thrive in.

Whether you’re leading projects solo or doing your best inside someone else’s system, structure is your superpower. A good process doesn’t box you in—it gives you room to do your best work.

Lead with clarity. Stick to your framework. And know that protecting the process is how you protect the product.