Project implementation - one step at a time

Original author: Piotr Oktaba
  • Transfer
The project can be described as a list of actions that, if successfully completed, lead to a certain result. Actions can be performed by one or more performers. The number of such actions can range from tens to thousands. A project can last for several days, months or years. There are hundreds of methodologies and tools that are designed to facilitate the organization and implementation of projects. Each of them is more or less suitable for certain types of projects. Some of them are mixed. Some are techniques that may be useful in various situations.

One such technique is this: take one step at a time.

We all know that one of the most important and crucial stages of the project is its final stage. This is the time when the result of the work, whatever it may be, is presented to the client, the public or begins work without notifying anyone. During this period, the most complex problems are identified and resolved. It often happens that the work of many, many is discarded and cannot be realized due to the implementation of new solutions. In general, many projects at the final stage make a finishing spurt. As a departure from the old system using new solutions, and the integration of new solutions - all this is very difficult, creates many stressful situations and brings considerable harm.

One of the fundamental principles that can be used to eliminate such difficulties can be taken from the Scrum methodology. An incomplete work item (you can imagine it as an elementary unit of work) can be considered completed if it corresponds to the so-called. "Conditions of implementation." Implementation conditions may vary from project to project. For some teams, this may mean that the regression condition is fulfilled. However, one of the most indicative execution conditions is that the work item is completed and performed on the production system. Given that the breakthrough cannot last more than 3 weeks, it turns out that every 3 weeks it is necessary to implement all the completed elements in the target environment. As a result, there will be no “finishing jerks” in the process of completing the project. There will be no fundamental changes and changes in the system.

How can this principle be used for smaller tasks? Whatever you start to do, whether it is a project or a separate task, think about how to divide it into small stages that would meet the following criteria:

  • Each stage makes final changes to the production process, no further changes are required at this stage;
  • Each stage has a certain value, either for users and the system, or to ensure the implementation of subsequent stages;
  • After completing each stage, the system is in a stable state, nothing can go wrong if no progress has been observed for weeks.


The benefits of this approach are quite obvious. At the final stage of the project, there will be no significant changes. There will be only a handful of small additions. However, this approach has one significant drawback: cost. Depending on the size and type of project, the cost with this approach can be significantly higher. But this is not always the determining factor.

The idea outlined above may seem impossible at first glance. However, most problems can be solved using this method. It is only necessary to find the point of application of effort and means that will allow it to be introduced into the workflow. Consider the process of changing the layout of a huge project system with hundreds of modules. The first approach that comes to mind is to spend a few months migrating, then apply all the changes to the system in a while, and switch the “big switch”. The likelihood of serious problems and disruption of the company is extremely high. In fact, you can bet that several elements will not work at all.

Modular migration may also not be the best solution. The simultaneous use of two layouts in the same system for months can cause great difficulties for developers and lead to an additional daily load on them. In order to apply the principle of small steps, it is necessary to “wrap” the old system in a new one. What does this mean? As a first step, the principle of turning the new system to the old one is used. Then, step by step, the functionality moves to the new layout system, which happens under the supervision of developers and CI. All small changes are implemented immediately upon completion. Result: no drastic changes at the end of the project.

Another example is migration from one source code management tool to another. If a company has dozens of systems using such a tool, requiring reconfiguration or reconfiguration, most likely, it will be necessary to stop the company for several days (or even weeks). In order to cope with this task and apply the method of small steps, you can develop such an action plan. All changes to the old system must migrate in real time to the new source code management tool. Thanks to this method, all systems can be reconfigured step by step to a new solution, while all the company staff will use the old solution. After the appearance of confidence that all systems are working correctly, the transition will only be to inform users:

Using the “one step at a time” approach can prevent a big headache at the project completion stage. It also allows you to implement projects that in other ways could not be implemented or would cause great difficulties. However, this comes at a price. Often for the successful application of this approach, it is necessary to organize the appropriate base and create the necessary funds. To use or not to use this approach, as always, must be decided in each case, depending on the circumstances.


Also popular now: