Blog
How to build a software development team: roles, size and structure
How to build a software development team: which roles to hire first, how big a team should be, how to split it as it grows, and how to tell it is working.
Building a software development team starts with the work your product needs over the next six to twelve months. Name one person who decides what gets built. Hire engineers who can carry a change from the screen to the database between them, and make sure someone covers design and testing from the first week, even if nobody has those job titles yet. Keep each team small enough for everyone to talk to everyone; the Scrum Guide puts that at “typically 10 or fewer people”. Past that size, split into a second team along the lines of the product. Then judge the team by how often working software reaches users and how often a release has to be fixed.
What is a development team?
In the 2020 Scrum Guide, Developers are the people “committed to creating any aspect of a usable Increment each Sprint”. Put plainly, a development team is the group that turns a decision about what to build into software people can use, and it owns that result together.
The guide gives two traits worth copying even if you never run Scrum. A team is cross-functional: its members have all the skills needed to deliver, so work does not sit in a queue for another department. It is also self-managing, deciding internally who does what and how, while a separate role decides what matters most. Our guide to SDLC models explains how Scrum organizes that work into sprints.
Software development team roles and responsibilities
Job titles differ from one company to the next, so a useful starting point is a list a government has published for its own service teams. The UK’s Service Manual names the roles or skills a digital service team needs, in the team or available to it, and the ones it may need as it grows. The US Digital Services Playbook asks for a single accountable product owner (play 6) and a team with experience in automated testing, DevOps and securing digital services (play 7). Mapped onto a commercial product, the roles look like this.
| Role | What they own | When you usually need it |
|---|---|---|
| Product owner or product manager | What gets built and in what order, and the authority to say no | From day one. Scrum’s wording: “one person, not a committee” |
| Technical lead or architect | How it is built: the stack, the shape of the code, security, and the choices that are costly to undo | From day one; in a small team, the most senior engineer |
| Software engineers (front end, back end or full stack) | Writing, reviewing and maintaining the code | From day one; full-stack engineers go further in a team of three or four |
| Designer | How the product works for the person using it: flows, screens, accessibility | Before the first screens are built, part-time at first |
| User researcher | Finding out what users need and testing designs with them | When there are users to study; early on the product owner and designer often share it |
| Tester or quality engineer | The testing approach, the automated test suite and the checks a release must pass | When manual checking starts to hold releases up; engineers write tests from the start |
| DevOps or platform engineer | Build pipelines, environments, monitoring and the running production system | When keeping deployments and environments working takes a real share of engineers’ time |
| Delivery manager | Clearing blockers and keeping the team’s working rhythm | When the product owner spends more time coordinating people than deciding, or there is more than one team |
In a team of three or four, people cover several of these at once. Each role still needs a named owner, because the work nobody owns, testing and monitoring above all, is the work that gets dropped when a deadline is close.
Who to hire first, and in what order
Hiring order follows the risk you are carrying. Early on, the biggest risk is building the wrong thing, so the first two seats go to the person who decides what to build and a senior engineer who can make the technical calls and write much of the first code. Hire senior first: the first engineers set the conventions, the tooling and the habits of review that everyone after them will inherit.
Two or three more engineers come next, chosen so that between them they can ship a feature end to end without waiting on anyone outside the team. A designer joins before the product has many screens, part-time if the work does not fill a week.
After that, add specialists when you can name the problem they solve. A dedicated tester earns a seat once releases wait on manual checks. A DevOps engineer earns one once engineers lose real hours to keeping environments and deployments alive. A delivery manager earns one once coordination crowds out the product owner’s real job. Hired before the problem exists, a specialist adds a person to every conversation without removing a bottleneck.
How big should a software development team be?
Team size matters because of conversations. Between n people there are n × (n − 1) ÷ 2 pairs who may need to talk, so the number of lines grows much faster than the headcount.
| People on the team | Possible one-to-one lines |
|---|---|
| 3 | 3 |
| 5 | 10 |
| 7 | 21 |
| 10 | 45 |
| 15 | 105 |
Going from 5 people to 10 doubles the team and more than quadruples the lines. That arithmetic sits behind the Scrum Guide’s “typically 10 or fewer people”, and behind its advice that a team grown larger should consider reorganizing “into multiple cohesive Scrum Teams, each focused on the same product”. The same arithmetic is a reason not to expect a late project to speed up the moment people are added: each newcomer opens new lines to everyone already there and has to be brought up to speed by the people who were writing the code.

How to structure a software development team
In 1968 Melvin Conway wrote that organizations which design systems “are constrained to produce designs which are copies of the communication structures of these organizations” (How Do Committees Invent?, Datamation). The practical reading is that the way you divide people will show up in the software. Put the front-end engineers in one team and the back-end engineers in another, and the product tends to grow a hard seam between the two, with every feature needing both teams to agree on a handover.
The structure that usually holds up better gives each team a part of the product it owns from end to end, such as billing, the customer portal, the mobile app or reporting. Each team has its own engineers across the layers, its own list of work and a product owner, and one product owner can serve two small teams. When a team grows past ten, split it along those product areas and divide the code the same way, so each team can release its part without waiting for the other. Shared concerns such as the deployment pipeline or a design system can move to a small platform team later, once two or more product teams depend on them.
How to hire engineers for the team
The US Office of Personnel Management describes a structured interview as one that puts questions fixed in advance to every candidate, in a set order, and scores each answer against one rating scale. Use that discipline for engineers, then add a short piece of work that looks like the job itself: extending a small piece of existing code, reviewing a pull request with a problem planted in it, or talking through how they would change a feature without breaking what depends on it. Once a product is live, much of the work is changing code that already exists, so that is the skill worth seeing.
Two points belong in the paperwork from the start. The first is employment status: the IRS weighs how the work is controlled, how it is paid and the nature of the relationship, so a contract that calls someone a contractor is one piece of evidence rather than the answer. Our comparison of in-house and outsourced development names the IRS tests, along with what an in-house developer costs once benefits are counted. The second is ownership: code an employee writes as part of the job belongs to the employer under US law, while code from an outside contractor is usually yours only once a signed transfer says so, as our guide to choosing a development company explains.
How to manage a software development team
Managing a small team comes down to a few habits that keep progress visible.
- One ordered list of work. The product owner keeps it and sets the order; the team decides how to do each item.
- A short cycle that ends in running software. One or two weeks, finishing with a demo of what now works rather than a status report.
- A written definition of done. For example: reviewed by a second engineer, automated tests passing, deployed to a staging environment and checked by the person who asked for it.
- The same path for every change. Every change is reviewed and goes through one automated build and test run before release, which is why the Digital Services Playbook asks for experience with automated testing and continuous integration.
To see whether the habits are working, measure delivery rather than effort. DORA groups its software delivery performance metrics into two sets.
| Metric | What it measures | Set |
|---|---|---|
| Change lead time | Time from a change being committed to version control until it is running in production | Throughput |
| Deployment frequency | How often the team deploys | Throughput |
| Failed deployment recovery time | How long it takes to recover from a failed deployment that needs immediate attention | Throughput |
| Change fail rate | The share of deployments that need an immediate fix, such as a rollback or a hotfix | Instability |
| Deployment rework rate | The share of deployments that are unplanned and made because of an incident in production | Instability |
DORA applies the metrics to an application or service, and its stated goal is for a team to improve on its own past, not to compete with other teams. It also warns that broad targets make teams more likely to “game the metrics”. Read them as a map of where work gets stuck, and look at the throughput and instability sets together, since raising speed alone is easy if nobody counts the failures.
Building a team takes time
Recruiting a full team takes months, and the first version of a product often cannot wait that long. One route is to keep the product owner on your own staff from the first day, have an outside team write the early versions, and bring engineers onto the payroll after the product has found its users. If you take it, settle the handover in the first contract, with a period in which both teams work on the code side by side, so that what the first team knows moves across with it.
If that route fits, Devrisen can be the first team. We supply a dedicated team on one monthly fee set before the work starts, or build a defined scope at a single fixed price agreed when scoping ends. Each week you see the software running in a demo. Our contracts pass the code and the intellectual property in it to you, so the engineers you hire later inherit code you already own. Our homepage sets out what we build as a custom software development company. A message to us gets a reply within one business day.
More about us: Custom Software Development Company.
Ready to scope your project?
Send us two sentences about what you need. We reply within one business day with the next step and any questions we need answered first.