The roles in a development project, explained

By Weapp · Updated

A digital project is typically staffed with a product owner, UX designer, frontend and backend developers, a tech lead, and a tester. In small projects, several roles can be carried by the same person. As a client, you should always own product ownership and overall prioritization yourself – that's the role you should never fully hand off.

A digital project full of titles can feel like a jungle if you’re not technical. What’s actually the difference between a tech lead and a project manager, and do you really need every role at once? The short version: roles are functions that have to be performed, not necessarily people who have to be hired. Here’s the map of who does what – and which roles you should never fully hand off.

The role map for a typical product team

In a fully staffed product team, a few central roles recur. Think of them as functions: in large projects, they’re different people; in small ones, several can be carried by the same person.

  • Product owner. Owns the vision, prioritizes what gets built and in what order, and makes the decisions. The role usually sits on the client side.
  • UX designer. Shapes how the product works and feels for the user – flows, interface, and whether it’s actually understandable.
  • Frontend developer. Builds what the user sees and interacts with.
  • Backend developer. Builds the engine underneath: databases, logic, accounts, and integrations.
  • Tech lead. Sets the technical direction, weighs architecture against quality, and holds the developers together technically.
  • Tester / QA. Makes sure what’s built actually works before it reaches users.

On top of this, there’s often a project manager who holds together planning, communication, and delivery. In an agency context, that’s usually your most common day-to-day point of contact.

Minimum staffing for small projects

Not every project needs a team of eight. For a simpler product or an MVP, staffing can be shrunk considerably without any function falling away – they just get shared across fewer hands.

A small but complete team can consist of one person combining UX and product thinking, one or two full-stack developers covering both frontend and backend, and a senior developer who’s also the tech lead. Testing gets woven into the developers’ way of working rather than having its own role. Product ownership stays with you as the client.

What matters isn’t how many people are involved, but that every necessary function is actually performed by someone. The danger isn’t a small setup – it’s a role everyone assumes someone else is handling, but nobody actually is. Ask yourself who owns each function rather than how many names are on the list.

A concrete example

Say you’re building a simple booking app as an MVP. You don’t need to hire six specialists. A UX designer sketches the flows and the interface, a full-stack developer builds both the app and the backend, and a senior developer steps in as tech lead and does quality review. You yourself are the product owner and decide what’s most important to include in the first version.

That’s four roles across maybe two and a half people. As the product grows and more features get added, you can split the roles apart – add a dedicated backend developer, a dedicated tester – as the need becomes real. Staffing for the size you actually have is almost always smarter than staffing for the size you hope for.

Roles you should never fully outsource

An agency can carry almost any role in the technical work. But one role should always have a clear owner on your side: product ownership.

No external party knows your business, your customers, and your goals better than you do. If you hand off the decisions about what to build and why, the project loses its compass – the team then builds what it thinks you want, rather than what you actually need. An agency can and should support the product owner with input and recommendations, but the final prioritization decision should be yours.

The same logic applies to overall steering: you should always have someone who understands the whole well enough to ask critical questions and make the big calls.

At Weapp, we put teams together based on what your specific product requires, and we like it when you keep hold of product ownership – it makes the result better. Want to know what a team would look like for your idea? Read about our services or get in touch with a short description.

Frequently asked questions

What does a tech lead do?

A tech lead is the team's technical owner. The role sets the technical direction, makes trade-offs about architecture and quality, and makes sure the developers pull in the same direction. The tech lead is also often your technical counterpart in tough decisions. In smaller teams, the person can both lead and code themselves; in larger ones, the role is more purely steering.

What's the difference between frontend and backend?

Frontend is what the user sees and touches – the interface in the app or on the web. Backend is what happens behind the scenes: databases, logic, accounts, and integrations. A frontend developer builds the experience, a backend developer the engine underneath it. Many features require both, and they need to work closely together.

Does a small project really need a tester?

Not necessarily a dedicated person, but testing has to be done by someone. In small teams, quality assurance is often a shared task, with developers testing each other's work. The point is that testing is an activity that's always needed – the only question is whether it's carried by its own role or woven into the team's way of working.

Which role has to exist on our side as the client?

Product ownership – someone on your side who owns the vision, prioritizes, and makes decisions with mandate. An agency can support that role but never fully take it over, because you're the one who knows what the business needs. Without a clear decision-maker on your side, even a skilled team loses direction and pace drops.

Can one person carry several roles?

Yes, especially in small projects. A senior developer can be both tech lead and builder, and a product owner can handle some project management. It works as long as the person has the time and skill for the combination. What doesn't work is pretending a role is filled when nobody is actually carrying it.