Skip to content
Back to articles

Practice · 7 min read

Freelancing inside a product team

Joining a product team as a freelancer means arriving in the middle of a story that started without you and will go on after you leave. Here's how I approach this kind of engagement, from the first week to the last day.

What a team really expects

A team that brings in an outside designer isn't just buying mockups. It's buying time: someone who becomes useful quickly, without needing weeks of hand-holding, and who leaves behind work the team can pick up on its own.

There are two pitfalls. The first is the freelancer who stays on the outside, delivers files, and stays out of everything else. The second is the one who shows up with their own habits and wants to redo everything their way. Both are costly. One because their work doesn't fit in, the other because they shake up a team that was working.

My approach fits in one sentence: step into the way things already work, and change only what's keeping the work from moving forward.

The first week: understand before producing

The first week isn't for producing. It's for understanding enough that everything after it is on target.

  • I read before I ask. Design files, documentation, open tickets, notes from the latest interviews. Every question I can answer on my own is one less interruption for the team.
  • I meet each role, one at a time. The product manager, one or two developers, the person who knows the users best. I ask them all the same questions: what works well here, what's getting in the way, what do you expect from me.
  • I look at the state of the design system. If there is one, I can assemble quickly. If there isn't, foundations need to come first, and that has to be said right away.
  • I restate the assignment in writing. At the end of the week, I send a few sentences: what I understood about the problem, what I'm going to deliver, what I won't do. If someone disagrees, that's the best time to find out.

That last point mirrors what I do in discovery on any project. Until the problem is framed in a few sentences everyone agrees on, you're not ready to design. For an outside contributor, it's even more true: nobody is going to clear up a misunderstanding in a hallway conversation.

Finding your place in the rituals

A product team runs on its rituals: daily standup, planning, review, retrospective. A freelancer can be tempted to skip them to protect production time. That's a mistake.

The daily standup tells me what the developers are building, and so where a design question is likely to come up. I don't say much: what I've delivered, what's blocking me, what I need.

Planning is the ritual where I'm most useful. At Adcleek, taking part in planning poker sessions taught me why some ideas that are simple to design are expensive to build. A designer in the room at that moment can suggest an alternative before the estimate kills the feature.

The review is a chance to show work in progress, not just finished work. Showing early means hearing objections while they're still cheap.

The retrospective I attend when I'm invited, and I listen more than I talk. It shows how the team really works.

When I can't be everywhere, I keep planning and review. Those are the two moments where design weighs on decisions.

Adopting the team's tools and rules

A freelancer doesn't impose their tools. If the team organizes its tickets a certain way, names its components by its own conventions, and documents in a specific place, I follow suit. My work should look like theirs, so nobody has to translate it.

This applies to the design system in particular. If there is one, I use it and respect it, even when I would have built it differently. If I need to add a component, I follow the library's contribution rule and propose it to the person who owns it. A contributor who slips in their own exceptions leaves the system more fragile than they found it.

When a rule really gets in my way, I raise it with a reason and a proposal. I don't quietly work around it.

Distance doesn't change this principle. On Xola, I worked with a CTO based in the United States and development teams based in India. Closeness didn't come from being in the same room, but from clear deliverables and regular communication. The same goes for someone who's only there for a few months.

Making your decisions visible

A permanent team member can rely on collective memory. A freelancer can't: whatever isn't written down leaves with them.

So I write down my decisions as I go, not at the end. For every structural choice, three lines: what was decided, why, and which options were ruled out. When someone later wonders why this flow works the way it does, the answer will be there.

I keep this documentation where the team already reads it: in component descriptions, in tickets, in the shared documentation tool. Not in a folder with my name on it that nobody will ever open.

Handing over during the engagement, not at the end

A handover isn't something you prepare in the last week. If it starts then, it's already too late.

Three habits help me.

  1. Working in the open. My files are shared from day one and organized like the team's. Nobody discovers my work all at once.
  2. Pairing someone from the team with each topic. A developer, a product manager, another designer. That person follows my choices and will be able to defend them after I leave.
  3. Doing design QA together. Comparing what was built with what was designed, screen by screen, with a team member. It's the best way to show what matters on a screen and what has room to move.

Leaving cleanly

The end of an engagement is prepared like a delivery. Before I leave, I check four things.

  • The files are tidy. Pages named, components up to date, drafts deleted or clearly flagged. A file only its author understands hasn't been delivered.
  • Every open topic has an owner. For each unfinished workstream, a name on the team and a note saying where I left off and what's still to be decided.
  • Decisions are written down. No useful knowledge exists only in my head.
  • A final meeting takes place with the team. Time to walk through what's been done, answer questions, and say honestly what I'd do next if I were staying.

The test is simple: the week after I leave, the team should be able to keep going without messaging me.

What wearing both hats brings here

Covering both design and product management helps a lot in this kind of engagement. I speak the language of trade-offs as well as the language of mockups. I understand why a feature was pushed back, what a priority costs the team, and what a product manager expects from a spec.

In practice, it shortens onboarding. Nobody needs to explain to me why the scope is tight. And when I propose a change, I present it with its cost and its expected impact, not just with a mockup.

In short

Freelancing inside a product team takes discipline more than talent. Understand quickly, respect what exists, show up at the right moments, write down what you decide, and hand over as you go.

A good freelancer isn't measured by what they produce during the engagement. They're measured by what the team can do after they leave.

Matis Thiebaud

Product Designer & Product Manager

Got an idea? Let's bring it to life.

I'm always up for working on new, ambitious projects, whether you're starting from scratch or refining an existing idea.

Book a call