Project implementation - one step at a time

The project can be characterized in the form of a list of actions that, subject to successful implementation, lead to a certain result. Actions can be performed by one or several performers. The number of such actions can vary from ten to thousands. The 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 can be useful in a variety of situations.

One of these techniques 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, to the public, or to start work without notifying anyone. During this period, the most complex problems are identified and eliminated. It often happens that the work of many, many people is discarded and is not being implemented due to the introduction of new solutions. In general, many projects in the final stage make a final spurt. As a departure from the old system using new solutions, and the integration of new solutions is all very difficult, creates a lot of stressful situations and brings considerable harm.

One of the fundamental principles that can be used to eliminate such difficulties can be found in the Scrum methodology. An incomplete work item (it can be presented as an elementary unit of work) can be considered completed if it corresponds to the so-called "Performance conditions". Terms of implementation may vary from project to project. For some commands this may mean that the regression condition is satisfied. However, one of the most indicative conditions of execution is that the work item is completed and executed on the production system. If we consider that the jerk can not last more than 3 weeks, it turns out that every 3 weeks it is necessary to introduce all completed elements into the target environment. As a result, in the process of completing the project there will be no “finishing jerks”. There will be no radical changes and reorganizations of the system. There will be only a quiet completion of the last elements and their introduction into production.
')
How can this principle be used for smaller tasks? Whatever you start to do, be it a project or an individual task, think about how to divide it into small steps that 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 specific meaning, either for users and the system, or to ensure that the subsequent stages are executed;
• After the completion of each stage, the system is in a stable state, nothing can go wrong if there has been no progress for weeks.

The advantages 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 major drawback: the cost. Depending on the scope and type of the project, the cost of such an approach can be much 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 with this method. It is only necessary to find a point of application of effort and means that will allow to introduce it into the workflow. Consider the process of changing the layout of a huge project with hundreds of modules. The first approach that comes to mind is to spend a few months on migration, then apply all changes to the system in some time, and switch the “big switch”. The likelihood of serious problems and disruption of the company is extremely high. In fact, you can beat that a few elements will not work at all.

Modular migration may also not be the best solution. The simultaneous use of two layouts in one 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 into a new one. What does this mean? As a first step, the principle of applying the new system to the old one is used. Then, step by step, the functionality moves to the new layout system, which is happening under the supervision of the developers and CI. All minor changes are implemented immediately upon completion. Result: there are no drastic changes at the end of the project.

Another example is the migration from one source control tool to another. If a company has dozens of systems using such a tool that requires reconfiguration or reconfiguration, you will most likely need to stop the company's operations 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 should be migrated 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 staff of the company will use the old solution. After the appearance of confidence that all systems are working correctly, the transition will be only to inform users: everything works on a new tool, you can switch to it, the old one will be disabled.

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 could not be implemented in other ways or would cause great difficulties. However, it has its price. Often, for the successful application of this approach, it is necessary to organize an appropriate base and create the necessary means. To use or not to use such an approach, as always, needs to be solved in each specific case, depending on the circumstances.