Leading a mobile team through rapid growth is hard. It’s not just about code. It’s people, process, and figuring out how to stay sane when everything’s moving fast.

I’ve been through it at Gymshark and with a bunch of scale-ups. Here’s what’s stuck with me.

How technical leadership evolves

Leading two developers isn’t the same as steering multiple squads. You’ve got to shift how you lead as your team grows. Here’s how I think about the different stages.

Still in the code (2–5 people)

You’re writing code every day. You lead by doing, and mentoring happens naturally.

What matters most:

Writing solid code and shaping the architecture
Pairing and mentoring junior devs
Setting the tone for how the team works
Building early habits for comms and culture

Keeping the wheels turning (5–15 people)

You’re not coding as much. Now it’s about keeping things aligned and moving.

What matters most:

Making sure teams talk to each other
Agreeing how decisions get made
Smoothing out process and tooling
Helping people grow in their roles

Big picture thinking (15+ people)

Now you’re thinking strategy, not sprint tickets. Your job is to make the whole system work.

What matters most:

Owning the tech vision and roadmap
Structuring teams to scale well
Hiring great people and helping them grow
Keeping stakeholders aligned without bullshitting

What Gymshark taught me

Gymshark grew fast. Really fast. It forced us to rethink how we led tech teams. These were some of the biggest lessons.

1. Comms don’t scale like code

What worked in a small team broke down when we got bigger. We needed structure to replace hallway chats.

What helped:

Writing down key decisions clearly
Regular cross-team tech demos
Clear, consistent code review habits
Known paths for escalating tricky problems

2. Autonomy needs guardrails

Autonomy isn’t chaos. It’s about setting boundaries so teams can run fast without stepping on each other.

What we put in place:

Shared principles for how we build
Clear interfaces between teams
Agreed tooling and infrastructure
Regular check-ins to stay aligned

3. Tech debt is a leadership issue

It’s not just messy code. It’s what you’ve chosen not to prioritise. Good leaders treat debt like any other business trade-off.

How to build a great mobile team

Hire for potential

Tech changes fast. I’d rather hire someone sharp and curious than someone with the “right” stack on their CV.

Make space to learn

The best mobile devs I’ve worked with are always learning. Give them room to experiment and grow.

Deliver, don’t just polish

Great code matters. But what you ship is what counts. Don’t lose sight of impact.

Common traps to avoid

Perfection paralysis

Trying to make every call perfect slows everything down. Sometimes “good enough” really is.

Too hands-off

If you step too far back, you lose sight of quality and direction. Stay close enough to spot trouble early.

Hero mode

If you’re solving every problem, you’re the bottleneck. Let your team take the wheel.

A few frameworks I’ve found useful

1. Technical decision matrix

Not every decision is life-or-death. Rate them by impact and reversibility. Treat them accordingly.

2. Growth conversations

One-on-ones that focus on where someone’s going, not just what they’re doing now.

3. Technical vision

Don’t just talk about the future. Write it down. Tie it to the business. Get buy-in early.

Wrapping up

Good technical leadership isn’t about being the smartest in the room. It’s about setting others up to do great work and making sure the tech supports the business.

The best bit? Watching your team grow. That, and seeing what a well-led team can actually deliver.