How to Optimize the Management of Your Development Process
In this article, I would like to share my experience as a team leader of WordPress developers. This experience covers work on various WordPress development services, such as themes and plugins, the development of new client sites, and resources for different levels of complexity and load.
While working on the projects, I repeatedly encountered situations where we did the same work and made the same mistakes. This forced me to consider the need to optimize the entire process. Let’s look at the most important points for optimizing management of the development process.
Detailed Planning and Designing
We will start with design. A properly designed project has already won half the battle. Junior developers tend to ignore this part, hoping a fast sketch will be sufficient. This is not reality. It is better to spend a few hours crafting a project design to better understand how it will work, which objects are needed, and how they will interact with one another. Even if you’re working on something simple, like a website with several post-types, take a piece of paper or a whiteboard and lay it out. Start by understanding how these post-types will interact, what properties and metapoles they will have, how the data exchange will take place, how the user will register, what forms will be on the site, and so on. This will make life easier when you and your team start writing code. Instead of wondering what’s happening on the other side of the project, you can focus on solving one problem at a time.
Breakdown of Tasks Into Subtasks
All tasks need to be divided into sub-tasks.The more detailed fragmentation you can achieve, the better. Don’t get too carried away, though, and stay within reasonable limits. I have one rule for this stage of managing processes – if there is a global task and I don’t quite understand how to complete it, I split it into subtasks until it becomes 100% clear. In practice, it’s as if we divide the site into pages, then into blocks, separate business functionality into functions, and so on. This works really well throughout the entire subsequent development process. In addition, I suggest you use checklists – this is an excellent visualization when setting and performing tasks. Besides, everyone likes to see how the project is being completed, item by item.
Accurate Time Estimation
From my previous experience as a team lead, I can say project time estimation is tough to gage. There are always (or almost always) overestimated or underestimated timeframes, given by developers, which causes the entire team to suffer. Optimistic deadlines are too often set, eventually resulting in either overtimes or in project delays – and this is not good for business. My team and I developed our own methodology for project time estimation, and it’s actually quite simple. Having divided the task into subtasks and knowing the exact time for each subtask, we can summarize it and calculate the total forecasted time for development.
Automation and Development Tools
Like every other sphere, programmers have their own well-developed tools. Our task is to bring all the tools together (e.g. an IDE, a version control system, a local server, and others) and be able to synchronize the team’s work. For example, we use PHP-Storm, Github, and Open Server. Of course, you can choose the tools that are most convenient for you, but the point of optimization is that we must make sure that all team members use these tools and their functionalities, at 100%.
During typical WordPress projects, the work is divided among 2-3 people. This is usually enough to complete the project if everything is accurately designed and distributed to each checklist. You should also assign tasks and subtasks using git and git-flow, so they do not overlap. Adding more people doesn’t always mean speeding up the project. If each team member competently works on their specific tasks, with time and resources effectively allocated, the project can be quickly and successfully completed.
If you create understandable and readable code, it helps facilitate further tasks and solutions – you no longer have to fight crutches or slurred pieces, instead of moving forward. Code quality can be regarded from several angles: meaningful names for variables, functions, classes, and general adherence to the WordPress code. The overall tip is to write code as if you’re going to support it for a long time. Currently, inexperienced developers tend to create files, name them “problem.functions.php”, and send all functionality there. At some point, the file becomes overloaded with completely different logic and the team spends all day trying to figure it out. A more productive method is to divide the code into folders and files, according to the business logic of the project. In doing this, you can save a lot of time in the development process itself, alloting you time to facilitate the process of making changes and updating code.
The development process isn’t always smooth. Sometimes, you must bear with it and be ready to debug your code. The whole thing can be divided into two categories. Debugging at the level of the programming language where we have php, is first. It’s most convenient to use the built-in tools in your IDE and ensure all developers have configured and used them properly. Second, we look at the use of special plugins, which allow us to collect and see valuable information: from the number of queries in the database, to the list of hooks used when loading the page. Among these plugins, I want to highlight Query Monitor, Mail Log, Health Check, Cron Manager. In addition to these, my team and I created the Dev Studio plugin to compensate for the functionality we lacked. This plugin allows us to see variables and constants, filters, hooks, data, etc., and makes it possible to set breakpoints. All of these plugins are free and can be found in the official WordPress repository.
Where Do Developers Spend Their Time?
We conducted a little research from several WordPress teams, and found an approximate schedule of developers’ work (this is not fully-fledged research, but it’s enough to visualize a typical day in the life of developer):
Typical tasks take most of developers’ time. For example, they start a new project, create a new topic, insert ready-made solutions, and hooks we previously used. This is not always the case, but it frequently happens in web studios that create client sites. Therefore, to best support developers, you should keep effective patterns and solutions in your knowledge base. As for the 20% of time spent on coffee and breaks, these are quite normal practices. Developers shouldn’t spend all day in a focused work mode. Doing so can actually lead to increased fatigue and burnouts. Taking a break is healthy for being more productive. Concerning new tasks – creating unique functionality and code – takes only 10% of the time for web studio developers. An interesting fact, these are also the tasks developers like the most. These tasks help improve the lives of users and customers, and are thrilling to work on.
In an ideal world, I would love to turn this diagram around so new tasks take up most of the time, leaving typical and routine tasks with less time. It isn’t easy to do, but you can take steps towards this scenario by using blanks (or boilerplates, starter-kits) and automate processes. For example, our team created a flexible starter kit theme. This theme was created on the principles of MVC, using Webpack. It is a flexible tool for quickly deploying the project and is also ready for scaling. In practice, we began saving 40% of our time in developing client sites. The theme is open source and is posted in the public domain – it can be found in the official repository of WordPress or on the git hub. And of course, you can make your own start theme or draft a plugin to meet your needs. The main idea is to clearly understand the requirements and create a flexible architecture.
I hope this recommendation will help you on the path to excellence! The fantastic WordPress platform offers tremendous opportunities, so let’s use them competently and elegantly.
Author: Oleksandr Zobenko, full-stack developer at Beetroot.
We hope this article was helpful. If you liked it, feel free to check out some of these articles as well!