Development Roles
Core software development roles in NUP
Development roles form the foundation of every NUP project team. These roles are inherited from OpenUP and represent the core competencies needed to design, build, and test software solutions.
Core Development Roles
Analyst
The Analyst represents customer and end-user concerns by gathering input from stakeholders to understand the problem to be solved and by capturing and setting priorities for requirements.
Primary Responsibilities
- Gather and analyze requirements from stakeholders
- Define the vision and scope of the system
- Document use cases and supporting requirements
- Prioritize requirements based on business value
- Maintain the glossary of domain terms
Tasks
| Task | Description |
|---|---|
| Define Vision | Establish clear understanding of what the system should accomplish |
| Find and Outline Requirements | Identify and document high-level requirements |
| Detail Requirements | Elaborate requirements with sufficient detail for implementation |
Additional Tasks
- Assess Results
- Create Test Cases
- Design the Solution
- Implement Test Scripts
- Manage Iteration
- Outline the Architecture
- Plan Iteration
- Plan Project
Artifacts
| Artifact | Purpose |
|---|---|
| Vision | Describes the "what" and "why" of the system |
| Use-Case Model | Captures functional requirements as use cases |
| Use Case | Detailed specification of a usage scenario |
| Supporting Requirements | Non-functional and supplementary requirements |
| Glossary | Definitions of domain terms |
| Work Items List | Prioritized list of work to be done |
Skills Required
Essential Skills:
- Expertise in identifying and understanding problems and opportunities
- Ability to articulate needs associated with key problems
- Effective collaboration through workshops and JAD sessions
- Strong verbal and written communication
- Knowledge of business and technology domains
Assignment Approaches:
- On small teams, this role is often shared among team members
- One or more team members perform this role exclusively for complex requirements
- Can be combined with the Tester role for smaller teams
Architect
The Architect is responsible for defining the software architecture, making key technical decisions that constrain the overall design and implementation of the project.
Primary Responsibilities
- Define the software architecture
- Make key technical decisions
- Document architecturally significant views
- Balance stakeholder concerns
- Reduce technical risks
- Organize team around the architecture
Tasks
| Task | Description |
|---|---|
| Outline the Architecture | Create initial architectural vision and key decisions |
| Refine the Architecture | Elaborate architecture based on requirements and risks |
Additional Tasks
- Assess Results
- Define Vision
- Design the Solution
- Detail Requirements
- Find and Outline Requirements
- Manage Iteration
- Plan Iteration
- Plan Project
Artifacts
| Artifact | Purpose |
|---|---|
| Architecture Notebook | Documents key architectural decisions and rationale |
| Design | Detailed design of system components |
Main Description
This role leads or coordinates the technical design of the system and has overall responsibility for facilitating the major technical decisions expressed as software architecture. This typically includes identifying and documenting the architecturally significant aspects of the system as views that describe requirements, design, implementation, and deployment.
This role is also responsible for providing the rationale for these decisions, balancing the concerns of the various stakeholders, reducing technical risks, and ensuring that decisions are effectively communicated, validated, and followed.
Skills Required
Essential Skills:
- Experience in both problem and software engineering domains
- Leadership ability to motivate and make critical decisions under pressure
- Excellent communication skills to earn trust and persuade
- Goal-oriented and proactive orientation with focus on results
Technical Traits:
- Tends to be a generalist rather than specialist
- Makes broader technical decisions
- Demonstrates broad knowledge and experience
Assignment Approaches:
- Should be engaged in the project from start to finish
- On smaller projects, may also act as Project Manager
- Works closely with Project Manager to organize the team
Developer
The Developer is responsible for developing a part of the system, including designing it to fit the architecture, prototyping the user interface, implementing, unit-testing, and integrating components.
Primary Responsibilities
- Design solution components
- Implement code according to architecture
- Write and run developer tests
- Integrate changes and create builds
- Ensure DevOps involvement
Tasks
| Task | Description |
|---|---|
| Design the Solution | Create detailed design for implementation |
| Implement the Solution | Write code that implements the design |
| Implement Developer Tests | Create unit and integration tests |
| Run Developer Tests | Execute tests and fix defects |
| Integrate and Create Build | Merge changes and produce builds |
| Ensure DevOps Involvement | Coordinate with operations team |
Additional Tasks
- Assess Results
- Create Test Cases
- Detail Requirements
- Find and Outline Requirements
- Implement Test Scripts
- Manage Iteration
- Outline the Architecture
- Plan Iteration
- Plan Project
- Refine the Architecture
Artifacts
| Artifact | Purpose |
|---|---|
| Build | Executable version of the system |
| Design | Technical design documentation |
| Developer Test | Unit and integration test code |
| Implementation | Source code and related files |
| Supporting Requirements | Technical requirements and constraints |
| Test Log | Results from test execution |
Skills Required
Essential Skills:
- Create technical solutions in the project's technology
- Understand and conform to the architecture
- Build developer tests covering required behavior
- Communicate design to other team members
- UML modeling ability (for visual design)
Assignment Approaches:
- On small teams, the role is often shared among team members
- Multiple developers should work together on the solution
- Can have specialized skills but needs broad understanding
Tester
The Tester is responsible for the core activities of the test effort: identifying, defining, implementing, and conducting tests, as well as logging outcomes and analyzing results.
Primary Responsibilities
- Identify tests that need to be performed
- Select appropriate test implementation approaches
- Implement individual tests
- Set up and execute tests
- Log outcomes and verify test execution
- Analyze and recover from execution errors
- Communicate test results to the team
Tasks
| Task | Description |
|---|---|
| Create Test Cases | Define test scenarios and expected results |
| Implement Test Scripts | Automate test execution where appropriate |
| Run Tests | Execute tests and record results |
Additional Tasks
- Assess Results
- Design the Solution
- Detail Requirements
- Find and Outline Requirements
- Implement Developer Tests
- Implement the Solution
- Manage Iteration
- Plan Iteration
- Plan Project
Artifacts
| Artifact | Purpose |
|---|---|
| Test Case | Specification of test input, execution, and expected results |
| Test Script | Automated test implementation |
| Test Log | Record of test execution and results |
| Work Items List | Defects and work items from testing |
Skills Required
Core Skills:
- Knowledge of testing approaches and techniques
- Diagnostic and problem-solving skills
- Knowledge of the system being tested (desirable)
- Knowledge of networking and system architecture (desirable)
For Automated Testing:
- Training in test automation tools
- Experience using test automation tools
- Programming skills
- Debugging and diagnostic skills
Assignment Approaches:
- One or more testing staff perform this role
- Can be combined with other roles on small teams
- May be separated based on automation experience levels
Role Interactions
Collaboration Flow
Communication Matrix
| From | To | Communication |
|---|---|---|
| Analyst | Architect | Requirements, constraints |
| Analyst | Developer | Detailed requirements |
| Analyst | Tester | Test scenarios |
| Architect | Developer | Design decisions |
| Architect | Tester | Testability requirements |
| Developer | Tester | Builds, test support |
| Tester | All | Test results, defects |
Role Assignment by Project Size
Small Team (3-5 members)
| Person | Roles |
|---|---|
| Team Lead | Architect, Developer |
| Developer 1 | Developer, Analyst |
| Developer 2 | Developer, Tester |
Medium Team (6-10 members)
| Person | Roles |
|---|---|
| Architect | Architect |
| Analyst | Analyst |
| Developer 1-4 | Developer |
| Tester 1-2 | Tester |
Large Team (10+ members)
| Team | Roles |
|---|---|
| Architecture Team | Architect(s) |
| Analysis Team | Analyst(s) |
| Development Team | Developers |
| Test Team | Testers |
| Integration Team | Developer/Tester mix |
Development Role Artifacts Map
Best Practices
For Analysts
- Engage stakeholders early and often
- Use multiple elicitation techniques
- Validate requirements with testable criteria
- Maintain traceability throughout
For Architects
- Focus on architecturally significant requirements first
- Document decisions and rationale
- Validate architecture through prototyping
- Communicate consistently with all teams
For Developers
- Follow coding standards consistently
- Write tests before or alongside code
- Integrate frequently
- Participate in code reviews
For Testers
- Start test planning early
- Automate regression tests
- Report defects with sufficient detail
- Track test coverage metrics
Related Resources
Compliance
This section fulfills ISO 13485 requirements for responsibility and authority (5.5.1) and human resources (6.2), and ISO 27001 requirements for security roles (A.5.2), secure development (A.8.25), and security testing (A.8.29).
How is this guide?
Last updated on