Development Basics

Software Development Roles and Responsibilities Overview

Software Development Roles and Responsibilities Overview

Every deliverable on a software team needs somebody who answers for it. Software development roles and responsibilities are the written-down version of who that is, spread across planning, design, building, testing, release and operations, and the version that works gives each deliverable one accountable owner.

The positions fall into product, design, engineering, quality and operations work. They run from product owner and UI/UX designer on one end to software architect, QA engineer and DevOps engineer on the other.

A title tells you very little about who owns what. The Scrum Guide 2020 dropped the word “role” altogether and put three accountabilities in its place (Developers, Product Owner, Scrum Master). Scrum.org describes them as the bare minimum set of accountabilities needed to run Scrum, not a job description (Scrum.org, November 2020).

Which product and design roles decide what the team builds?

The product owner orders the work. The product manager sets direction across releases, the business analyst turns stakeholder needs into written requirements, and the UI/UX designer decides how the product looks and behaves.

On a small team one person often holds two or three of these, which is normal. What each role hands to engineering still stays separate: a backlog, a roadmap, a requirements document, a design file.

Product owner

YouTube player

The Scrum Guide 2020 makes the product owner one person, not a committee, accountable for maximizing the value of the product.

Ordering the backlog, setting the Product Goal and keeping backlog items clear all fall under that single accountability. A product owner can hand the work to others, but the guide keeps the accountability with the owner.

Product manager

Direction beyond a single sprint sits here. The product manager owns the vision and the roadmap and weighs customer and market input against cost. Backing the product owner with priorities and requirements is part of the job too.

Scrum.org notes that Product Owner is an accountability while product manager is often an organizational job title, so one person can hold both. Scrum doesn’t forbid that, because the framework tracks accountability, not job titles.

Business analyst

Stakeholders rarely describe what they need in a form a developer can build from. Translating that into a written requirement is the business analyst’s job.

The outputs are requirements documents and user stories, plus acceptance criteria specific enough for a tester to pass or fail. The role often starts before the team is formed and stays through delivery.

UI/UX designer

Flows, wireframes, prototypes and the visual system all belong to the designer. Developers build from the resulting file, so UI and UX design output needs a named owner on both sides of the handoff.

Tooling has done a lot for that handoff. Figma’s Dev Mode, introduced in 2023, gives developers an inspect panel with measurements and code snippets, plus statuses marking which frames are ready for development (Figma Help Center, as of October 2026).

Engineering roles: what developers, architects and tech leads own

YouTube player

Developers own implementation. Above them, the architect shapes the system as a whole, and the tech lead steers technical direction inside one team.

Developers

Developers turn requirements and designs into working code, then maintain it. Most specialize by layer. Front-end people build the interface users see, in HTML, CSS and JavaScript, while back-end people handle business logic, databases, APIs and caching. A full-stack developer covers both and sometimes deployment too.

Reviewing a teammate’s pull request is part of the job, and a written process for reviewing code says who may approve.

GitHub enforces that rule in settings. As of October 2026, administrators can require a set number of approving reviews before a merge into a protected branch, and authors cannot approve their own pull requests (GitHub Docs).

There’s a catch, though. A “Request changes” review blocks nothing unless a ruleset or branch protection rule requires pull requests (GitHub Docs).

Software architect

Architect is a fairly new answer in Stack Overflow’s survey, and it landed high. The 2025 Developer Survey, with 49,000-plus responses from 177 countries, added architect as a new answer option and ranks it as the fourth most common role among respondents, at 6.1%.

A software architect makes the high-level technical decisions before large volumes of code exist, covering system structure, technology selection, integration approach and scalability plan. Those choices are the hardest to reverse once code depends on them.

Tech lead

Where the architect decides what the system should look like, the tech lead makes sure the team actually builds it that way.

Daily work covers code quality standards, task breakdown and unblocking developers, usually alongside coding.

Technical debt, the accumulated cost of shortcuts that make later changes slower, is also the tech lead’s call, including what to repay this quarter and what to defer.

Who owns quality, release and operations?

Once code exists, the questions change. Does it meet its requirements? Can that check run on every change? How does a build reach production, and does it stay up once it’s there? The QA engineer, test automation engineer, DevOps engineer and site reliability engineer each take one of those, and the release manager decides when it ships and who signed off.

QA engineer and test automation

YouTube player

A QA engineer owns the test plans and test cases and triages defects. Test automation engineers turn the repeatable checks into suites that run on every build.

Developers own unit tests. Beyond that layer, QA engineers own integration, end-to-end and exploratory testing, plus the defect log.

Selenium is a common example of the tooling. Its documentation describes WebDriver, an interface for writing browser instructions that run across many browsers, and Selenium Grid, which runs the same tests on different machines and platforms.

DevOps engineer and site reliability engineering

Site reliability engineering has a hard limit built in. Google caps operational work for its site reliability engineers at 50% of their time, with no more than 25% spent on call (Site Reliability Engineering, O’Reilly, 2016).

The rest goes to engineering projects that reduce future toil or add features. That cap is what separates the SRE role from an operations queue.

The DevOps engineer owns the delivery pipeline, meaning builds, automated tests and deployments. Because DevOps merges development and operations duties, this engineer sits between both teams.

Jenkins, described in its documentation as an open source automation server for building, testing and delivering or deploying software, is a common home for those pipelines.

Reliability and speed pull against each other, and an error budget settles it. The budget is the gap between a service’s reliability target and 100%, and it decides whether releases ship or reliability work takes priority.

Google Cloud’s DORA research program measures the result with deployment frequency, lead time for changes, change failure rate and failed deployment recovery time, and added deployment rework rate in its 2024 report.

Release manager

The release manager owns the release calendar and the go/no-go call.

Where nobody holds the title, the decision moves to the product owner and the DevOps engineer runs the release.

What project managers, scrum masters and engineering managers are responsible for

All three manage something, just not the same thing. The project manager watches scope, schedule, budget and risk, and the scrum master watches how well the team practices Scrum. Hiring, growth, performance and the general health of delivery belong to the engineering manager.

A project manager keeps the development plan for the project current and tracks risk, with status reports going out to stakeholders. Jira is the usual place for backlog and sprint status.

Who talks to stakeholders depends on the framework. The project manager carries it in a plan-driven setup, while in scrum the product owner works with stakeholders on the backlog.

The Scrum Guide 2020 makes the Scrum Master accountable for establishing Scrum and for the Scrum Team’s effectiveness. It describes Scrum Masters as true leaders who serve the team and the larger organization.

The engineering manager runs one-on-ones, career conversations and hiring, and flags cross-team dependencies before they block delivery.

Who owns each phase of the software development life cycle?

The product owner answers for planning and requirements, the architect for design, developers for the build, QA for testing, and DevOps for release and operation. Everyone else is consulted.

ISO/IEC/IEEE 12207:2026, published in April 2026, defines life cycle processes from conception through retirement but does not require any specific life cycle model. It assigns no people to phases, so every team has to draw that map itself.

Most teams start from the seven phases of the SDLC and attach one owner to each.

PhaseAccountableResponsibleConsulted
Planning and requirementsProduct ownerBusiness analystTech lead, designer
DesignSoftware architectTech lead, designerDevelopers, QA
BuildDevelopersDevelopersArchitect, QA
TestQA engineerTest automation engineerDevelopers
ReleaseProduct ownerDevOps engineerQA, tech lead
MaintenanceSRE or DevOps engineerDevelopers, SREProduct owner

Treat this as a working default for a mid-size scrum team, built from the Scrum Guide’s accountabilities. It is not a standard, so change a cell when your team differs. The one rule that holds is one accountable owner per row.

Who approves a release?

In scrum, product decisions sit with the Product Owner, so the go/no-go call does too. Developers answer for an Increment that meets the Definition of Done (Scrum.org).

Teams on a fixed software release cycle usually give that call to a release manager instead. Swap the name in the Release row.

The merge gate configured in GitHub is the only approval a tool enforces. Every other sign-off holds only if the team honors the matrix.

How the Scrum Guide assigns accountability on a team

The Scrum Guide 2020 defines three accountabilities (Developers, Product Owner and Scrum Master) and holds the whole Scrum Team accountable for a valuable, useful Increment every Sprint.

The 2020 edition dropped the word “role” and the phrase “Development Team”. Scrum.org describes the result as the bare minimum set of accountabilities needed to run Scrum, not a job description (Scrum.org, November 2020).

Developers always answer for the Sprint Backlog, the plan for the Sprint. They also answer for quality, by adhering to a Definition of Done, and for adapting the plan each day toward the Sprint Goal. On top of that, they hold each other accountable as professionals.

“Developers” does not mean programmers only. It covers anyone committed to creating a usable product increment each Sprint, which puts testers and designers on the team inside the term.

The Daily Scrum belongs to them as well. When the Product Owner or Scrum Master works on Sprint Backlog items, they join it as Developers (Scrum Guide 2020).

Authority is split too. Only the Product Owner can cancel a Sprint, and the Guide states that a Scrum Team has no sub-teams or hierarchies.

Titles sit outside the Guide. Scrum.org says Scrum Master can stay a job title, but the job description will be larger than the accountabilities, which each organization extends.

Not everyone reads the 2020 change as clean. Scrum.org says swapping “roles” for “accountabilities” does not change Scrum, while t2informatik reports a critique that the text still lists tasks, such as Developers creating the Sprint Backlog.

The numbers in the Guide are small. There are 3 accountabilities, a typical Scrum Team has 10 or fewer people, and the Daily Scrum, an event for the Developers, runs 15 minutes (Scrum Guide 2020).

Where software development roles overlap and how to tell them apart

In each overlapping pair, the dividing line is decision authority and reporting line, not the task list. Two people can work the same backlog and still hold different jobs.

Product owner vs product manager

The fastest test is permission. Scrum.org ties the Product Owner accountability to real authority over product decisions. Without it, the Product Owner risks becoming a scribe for stakeholder wish lists.

A September 2025 Scrum.org post goes further. The work largely overlaps, and the only difference is that a Product Owner uses Scrum to run product management while a product manager is not tied to Scrum.

SAFe reads it differently. It staffs two levels, with product owners at team level and a product manager at release-train level.

So the sources split on whether this is one job or two. Follow the framework the team actually runs, and write the reporting line down.

Scrum master vs project manager

A scrum master has nobody reporting in, can’t fire a team member and carries no delivery accountability. A project manager sets milestones and timelines, and the role fits best where scope and requirements are clear before work starts.

Scrum.org says a project manager’s responsibilities do not vanish in Scrum. They disperse across the Scrum Master, Product Owner and Developer accountabilities.

A Scrum Master who behaves like a project manager risks breaking the team’s self-management.

Tech lead vs engineering manager vs software architect

StaffEng, Will Larson’s guide to staff-plus roles, says an organization needs roughly one tech lead for every eight engineers.

The tech lead guides the approach and execution of one team and partners closely with a single manager. An architect owns direction, quality and approach within a critical area, which combines technical constraints, user needs and organization-level leadership.

The engineering manager owns the people side. Some companies add a tech lead manager role, a hybrid that sits on the management ladder and carries people responsibilities.

When one person holds two of the three, name which hat decides on code and which decides on people.

How responsibilities change from junior to lead

What changes first on the way up is scope. A junior owns tasks, a mid-level engineer owns work inside the team, a senior owns ambiguity, and a lead owns direction across teams.

GitLab’s public handbook shows the ladder concretely. Juniors own their own work, learning and developing. Intermediates work within the team, and seniors take large issues with vague requirements, plus coaching and mentoring. Staff engineers and managers work across teams.

GitLab’s engineering career framework, whose Senior page was last modified in March 2026, expects seniors to deliver even when requirements are unclear. It also carries every intermediate competency forward, so nothing drops off with the title.

That is the part ladders hide. Responsibilities accumulate, and a senior still writes code with mentoring added on top.

Above senior the path splits. GitLab runs a dual career path, with Staff on the technical side and Manager on the people side, both operating across teams.

StaffEng notes that the tech lead seat is, for many engineers, their first staff-level role.

Which roles a software team needs at each size

A small team needs a product owner, developers and some testing and release capability. Dedicated architects, platform engineers and release-train roles arrive only as the system and the organization grow.

StageStructureRoles presentTypical merges
Startup or MVPOne scrum teamProduct owner, developers, designerFounder as product owner, developers also test and deploy
Mid-size productStream-aligned teams plus a platform teamProduct owner and tech lead per team, QA, DevOps, engineering managerArchitect work sits with senior tech leads
EnterpriseSAFe release trainRelease Train Engineer, product manager, system architect, product owners, scrum mastersFew, roles specialize

Team Topologies, by Matthew Skelton and Manuel Pais (2019), names four team types, stream-aligned, platform, complicated-subsystem and enabling. Stream-aligned teams are the default, and the other three exist to cut the load on them.

Platform engineers enter when stream-aligned teams spend their time on infrastructure instead of product work. The authors call the smallest useful platform the thinnest viable platform, and it can be a wiki page.

The dedicated architect shows up late. StaffEng places the architect role at around 100 engineers in recent fast-growing companies, and the right-hand role at around 1,000.

That sits oddly with the 2025 Stack Overflow Developer Survey ranking architect among top developer roles. The two measure different things. StaffEng describes the scope of the work, while the survey counts self-reported roles.

A SAFe release train holds roughly 50 to 125 people, per the Scaled Agile Framework site, while ProductPlan’s glossary puts the ceiling at 150. The added Release Train Engineer and system architect layers are one visible difference between SAFe and plain Scrum.

Combining roles safely

Merge roles that pull in the same direction. Keep apart the roles whose job is to challenge each other.

Developer and tester is a safe merge for unit-level checks, and so is tech lead and architect while the team is small.

Product owner and Developers costs more. The Product Owner owns value while Developers own quality, and that tension is hard for one person to hold (Scrum.org).

Product owner and scrum master is the pairing to avoid. Scrum.org advises against combining them and sees a significant conflict of interest, even though the Guide does not forbid it.

When fixed role definitions stop working

Fixed role definitions break down in a few predictable ways.

A RACI matrix (responsible, accountable, consulted, informed) pays off across teams and recurring processes. On a team of three, one person holds most cells, and the matrix only restates who is on the team.

Too many consulted roles cause trouble too. University of Washington IT’s RACI instructions advise minimizing the number of consulted and informed roles to reduce confusion. Standard RACI practice adds that someone must be accountable for each activity.

Self-managing teams are another case. The Scrum Guide describes a Scrum Team as self-managing, meaning members decide internally who does what, when and how (Scrum Guide 2020). A task-level matrix imposed from outside cuts against that, so keep matrices at the accountability level there.

Then there are the seams between roles, which end up in the system itself. Melvin Conway’s 1968 paper “How Do Committees Invent?” holds that organizations designing systems produce designs that copy their communication structures. Every role boundary adds a handoff, and handoffs tend to harden into interfaces in the code.

If a role split needs revising, it usually shows. Watch for a decision nobody owns, sign-offs waiting on a long list of consulted roles, tasks assigned to the team from outside it, and service boundaries that match the org chart rather than the problem.

Software Development Roles and Responsibilities FAQ

Is a software developer the same as a software engineer?

In most organizations, yes. No standard separates the two titles, so any difference comes from company convention.

Compare the scope and ownership written into a job level, not the word in the title.

How do Kanban teams handle roles?

Kanban prescribes none, according to Kanban University. Teams keep their existing roles and put a board on top.

Two roles, the Service Delivery Manager and the Service Request Manager, have emerged in practice, but Kanban University presents them as options, not requirements.

Should a team hire in-house, outsource or augment its developers?

Augment when leadership and a roadmap already exist and you need a skill under your own direction. Outsource a bounded project when a vendor should run delivery, and hire in-house for core, continuous work.

The deciding question is who owns the outcome.

Does DevOps replace the operations team?

No. DevOps moves operations work into shared ownership between development and operations, and automates much of it, but the work itself stays.

Without a named owner for on-call and incident response, those duties fall between teams.

Which Ownership Decisions a Team Should Settle First

Software development roles and responsibilities are best settled in a set order. Name one owner for each release decision first, then keep the people who check each other’s work apart (an author shouldn’t also be the approver), and bring in specialists as team counts grow.

Ownership gaps stall every other decision, so they come first. Specialists add the most headcount and pay off only at scale, so they come last.

At StaffEng’s ratio of one tech lead per eight engineers, a company reaches about 12 tech leads before the dedicated architect typically appears at 100 engineers. Tech leads carry cross-team design decisions for that whole stretch.

Separation has a price. Every extra position adds a handoff and a salary, while a merged position saves both and loses a check. Teams that merge should write down who decides in a dispute.

Methodology choice follows from this design, because the types of software development methodologies differ in which accountabilities they name.

Bogdan Sandu

Stay sharp. Ship better code.

Every week: one curated article, one tool worth knowing, one tip you can use tomorrow. No noise, no padding.