Skip to main content
Spiria black logo

A day in the life of a software developer

Software is now an integral part of our daily lives: not a day goes by that we don’t use an on-line shopping platform, a mobile application, an ATM, a self-serve check-out at the grocery store, and so on and so forth.

All these systems have to be initially thought up and developed, then continuously maintained throughout their lifecycle. And we use such systems every single day, whether we realize it or not. But have you ever given any thought to the work of the programmers behind the tools that we couldn’t function without?

As a developer specializing in Web applications, I’d like to give you a peek at my day-to-day work, tasks and challenges. Of course, every software development project is unique, and every team has its own way of doing things, but this overview is still representative of the general approach taken for most software development projects.

But let’s start with clearing up a concept first: the all-encompassing word “development”, which covers the general process of causing a piece of software to be born, isn’t just about developers. In fact, development calls upon many different types of knowledge and professionals that have nothing to do with writing code.

The software development cycle

In the modern software development cycle, called “Agile”, an application is in continuous development:

Development cycle.

  1. Analysis — Needs analysis: new features required, bugs to fix, etc.
  2. Design — Development of mock-ups, software architecture, etc.
  3. Implementation — Development per se (“coding”).
  4. Tests — Quality Assurance (QA) to confirm the system is working as expected and to find bugs that may have gone unnoticed during development.
  5. Deployment — Launch of product.

Best practices require the development process to go through each of these stages in regular cycles, in order to obtain regular updates during production. Each cycle, called “sprint”, typically lasts anywhere from one to four weeks, depending on the nature of the project. However, in case of an emergency, for example when a “hotfix” is required, an entire cycle can be completed in as little as a day.

The other thing to remember is that not all cycles produce changes that are visible to the end-users of the application. For example, a cycle could deal just with underlying analysis or background architecture changes to lay the groundwork for future features, or to stabilize the platform. Also, any given feature can be split up in several smaller, simpler tasks to spread the load between several developers.

Sometimes, depending on how the teams are organized within the company, developers are called upon to take on tasks at every phase of the cycle. A good developer is therefore versatile and able to quickly adapt to any given situation.

While most companies have a dedicated QA team to test applications and catch bugs before the launch of any new features, developers still have to test their code themselves during implementation to fix as many bugs as possible, as early as possible, in the production process.

Also, the different phases of the development cycle are not always sequential. For example, the analysis and design phases of the next cycle can be performed simultaneously with other phases of the current cycle.

The analysis phase usually involves the following tasks:

  1. Needs analysis: Identification and prioritization of bugs and new features for the next cycle.
  2. Documentation: Documenting technical requirements to meet the identified needs. Splitting up of complex features in several simpler sub-tasks.
  3. Estimation: Estimating the complexity of each of the identified tasks, and time required to complete them.
  4. Validation: Planning and validating the contents of the next development cycle.

The needs analysis phase is initiated in close collaboration with the client, represented by the “Product Owner”; the development and Quality Assurance teams usually get involved at the final stages of estimation and validation.

The coder’s work

As for actual development work, developers usually undertake the following work for each task:

  1. Implementation of a task in the code (adding the feature in the code or adjusting existing code to fix a bug):
    • Research and documentation (using an external software library, finding an existing solution to fix a bug, exploring technological alternatives, etc.)
    • Adding unit tests, functional tests or integration tests, depending on the project.
    • Testing new features in a dedicated development environment.
  2. Opening up code review to other developers:
    • Adjustments and corrections based on the code review feedback (if applicable).
  3. Deploying new features in the dedicated QA environment:
    • Adjustments and corrections for bugs found by the Quality Assurance team (if applicable).

Once all the tasks are completed and collated, the completed “sprint” can be deployed to production.

Finally, it’s important to know that all of the various phases of the development cycle are not stand-alone, but rather interrelated.

For example, after the implementation of a new feature, if a bug is found by the Quality Assurance team, the developer responsible for the task will fix it by going back to the implementation stage.

On the other hand, if a bug is found in actual production during a cycle, it is prioritized and analyzed. Depending on its seriousness, it can be corrected as a “hotfix”, or inserted in the cycle currently underway, potentially replacing another feature in the next deployment, or fixed in a future cycle.

Collaboration and communication

Collaboration and communication between the various teams is the secret to developing a robust, quality application efficiently. Developers must be in constant contact with each other and with the other members of the team, as needed, throughout the cycle.

Ideally, communication takes place directly and in person, but depending on the size of the company and the location of the client, sometimes, teams are spread out in different cities, countries, or even continents. Meetings and discussions that take place virtually are no less important than in-person ones. Nowadays, with many companies allowing their employees to work remotely, the quality and frequency of communications within the team is all the more important.

A typical day for a developer would be made up of the following tasks, not necessarily in the following order:

  • Check in with the rest of the team (for example, a “scrum” meeting).
  • Review code for features completed by other developers.
  • Adjustment of completed features following code review by other developers or feedback from the QA team.
  • Development of new features (implementation + test).
  • Contribute to estimating future features (generally once per “sprint” or cycle, depending on requirements).

Of course, all of this will vary depending on the project and the role of each developer within the team.

In conclusion, software development is a complex process that is constantly evolving. Aside from developers, it involves many different players that are just as important as the developers. Next time you use your favorite application, give a thought to the amount of work and effort that was put in by all the various development teams to make it happen.

Discover our
success stories.

A software development project?
Contact us!

This entry was posted in Working environment
by Marc-André Malouin.
Share this article