Skip to main content

4.7. How Work Gets Done

Every team has its own unique workflow, but there are some common elements that most engineering teams share. Understanding these can help you navigate your role more effectively and contribute to your team's success.

Task Management

Most software engineers work with a "ticket based" task management system (like Jira, Trello, or Asana) to track their work.

Software engineers are assigned to tasks of varying sizes, from small bug fixes to large features.

How granular these tasks will vary depending on the team and project, but they are usually broken down into manageable pieces that can be completed in a few days or weeks.

Some of the tasks you might be assigned include:

  • Tasks: The most generic type of work item, could be anything from fixing a bug to implementing a new feature.
  • Bug Fixes: Addressing issues reported by users or discovered during testing.
  • Stories: A story is a task written from the perspective of an end user that describes a feature or functionality they need. Stories are often used in Agile methodologies to define work that delivers value to users.
  • Spikes: A spike is a research task where the team investigates a specific problem or technology to gain knowledge or reduce uncertainty. Spikes are often used when the team needs to explore options before committing to a solution. They reduce uncertainty and help the team make informed decisions.

Each task will have a description, acceptance criteria, and often a priority level.

The Acceptance criteria is the set of conditions that must be met for the task to be considered complete. It helps ensure that everyone understands what "done" means for that task.

Depending on where you are in the software development lifecycle, you will see different types of tasks. For example, if you are in the early stages of a project, you might see more design and architecture tasks, while in the maintenance phase, you might see more bug fixes and performance improvements.

What Are Sprints?​

The current most common way that engineering teams organize their work is through sprints.

A sprint is a fixed period of time (usually 1-4 weeks) during which a team works to complete a set of tasks.

At the beginning of each sprint, the team holds a sprint planning meeting to define what work will be done, estimate effort, and assign tasks.

In this meeting, the team decides which items from their backlog (a prioritized list of work) will be tackled in the upcoming sprint. They break down larger tasks into smaller, manageable pieces and assign them to team members.

When a sprint is completed, the team holds a sprint review to demonstrate what they accomplished and gather feedback from stakeholders. This is often followed by a retrospective, where the team reflects on what went well, what didn’t, and how they can improve in the next sprint.

Using the data accumulated across multiple sprints, teams can use their velocity (the amount of work completed in a sprint) to estimate how much work they can take on in future sprints. This helps with planning and setting realistic expectations.

Processes​

Sprints are often part of a larger software development process and are not the only way teams organize their work. Here are some common methodologies and processes you might encounter:

  • Agile: An iterative approach that emphasizes flexibility, collaboration, and customer feedback. Teams work in short cycles (sprints) to deliver small increments of value.
  • Scrum: A specific Agile framework that includes defined roles (Scrum Master, Product Owner), ceremonies (sprint planning, daily stand-ups), and artifacts (product backlog, sprint backlog).
  • Kanban: A visual workflow management method that focuses on continuous delivery and limiting work in progress. Teams use boards to track tasks and prioritize work.
  • Waterfall: A more traditional, linear approach where each phase of development is completed before moving on to the next. Less common in modern software development but still used in some industries.

The reality is not team actually follows a single methodology perfectly. Most teams adapt elements from multiple approaches to fit their specific needs and culture.

Common Rituals​

Rituals are regular practices that help teams stay aligned, communicate effectively, and maintain a healthy workflow. Common rituals include:

  • Daily Stand-ups: Short, focused meetings where team members share what they worked on yesterday, what they plan to work on today, and any blockers they’re facing.
  • Sprint Planning: A meeting at the beginning of each sprint to define what work will be done, estimate effort, and assign tasks.
  • Retrospectives: A meeting at the end of each sprint to reflect on what went well, what didn’t, and how the team can improve in the next cycle.
  • Code Reviews: A process where team members review each other’s code to ensure quality, share knowledge, and catch potential issues before merging changes.
  • Pair Programming: A practice where two or more developers work together on the same code, sharing knowledge and improving code quality through collaboration.
  • Backlog Grooming: Regularly reviewing and prioritizing the product backlog to ensure that the most important work is being addressed in upcoming sprints.
  • Demo Days: Presenting completed work to stakeholders or the wider team to showcase progress and gather feedback.

Every team will have its own set of rituals that work best for them, you should expect to adapt to the rituals of your team when you join a new company.