Agile and Hybrid Approaches to Kernel and Driver Development: Pros, Cons, Examples

When planning a driver development project, your team will likely focus on technical challenges: picking the technology stack, deciding on an architecture, and gaining relevant expertise. However, even with the most suitable toolset and skillset, you risk missing deadlines and going over the budget if you choose the wrong project management strategy.

Project management challenges are equally important as technical ones, as they influence the delivery date, budget compliance, and final product quality. One of the key problems is that out-of-the-box management approaches rarely fit driver creation projects due to their complexity.

To efficiently manage driver and kernel development projects, Apriorit’s project managers (PMs) often customize well-known Agile and hybrid methodologies and practices. Such customizations, based on more than 20 years of project management experience, help us keep driver development projects under control and deliver quality products to our clients.

In this article, we share examples of Agile and hybrid approaches to driver development. This article will be useful for team and product leaders looking for a way to control the driver development process while keeping it flexible and open to changes.

Why do driver development projects need a special management approach?

Kernel and driver development is a crucial component of system programming that focuses on creating software components that enable the operating system to interact with and control hardware devices. It requires a deep understanding of both hardware and operating systems, making it an essential part of system software development. 

Compared to application programming, system programming requires a developer to know a low-level language, hardware capabilities, and low-level components their system interacts with.

Let’s take a look at the key differences between system and application programming:

Criteria	System (driver) programming	Application programming
Language	Low-level languages: C/C++, assembly, Rust	High-level languages: Python, C#, Java, PHP
Target platform	OS or hardware	Other software or servers
Performance	Focus on code productivity and optimization	Focus on speed of operation
Cybersecurity risks	Can introduce critical risks and lead to device hacking or bricking	Risks are less critical and can be reduced with other software
Development complexity	Each project requires deep research and rare development skills	Projects are often based on well-known frameworks and libraries
Development speed	Slow, with each commit requiring debugging and compilation	High, with code often compiled on the server side
User interfaces (UIs)	Systems rarely interact with end users and need UIs	Applications mainly interact through UIs

Say you want to develop a web application. In this case, you’ll likely prioritize quick delivery of the first product version and be forgiving of errors. Application programming is often based on well-known frameworks and practices that help a PM plan and control the project.

On the contrary, developing drivers requires unique skills and approaches, as drivers are complex products with little room for error. If a driver works incorrectly, it can crash or brick the hardware. Drivers also often can’t be updated after release. A PM has to understand and take into account these characteristics when choosing the most suitable project management methodology.

In the next sections, we share our experience managing a complex driver development project using Agile, Waterfall, and hybrid approaches.

3 ways to manage a driver development project

Once you decide to start a driver development project, be ready to face a lot of unique tasks that call for unique development and project management skills. At the same time, some activities like testing, code versioning, and team interactions are similar for various projects. At Apriorit, we’ve formulated our own practices for handling both unique and typical activities of kernel and driver development. 

Let’s explore three different ways to manage a driver development project based on a real-life example. In one of our recent projects, we worked on a Windows minifilter driver that should analyze traffic according to certain rules. Here are the key project requirements:

• Implementation of key functionality, such as for intercepting traffic and applying filtering rules specified in a JSON file
• Support for Windows 10 and later versions
• Log processing and transmission
• High and stable driver performance
• Optimized resource use and efficient use of device memory
• Reliable data protection and cybersecurity
• Compatibility with other system components and drivers

Now, let’s take a look at how to implement these requirements and manage the project using Scrum, Waterfall, and Agile hybrid methodologies. We’ll also examine the advantages and disadvantages of each approach for this type of project.

1. Using Scrum for system programming

Scrum is an Agile approach for project management based on an iterative approach, self-organization of the project team, and continuous collaboration among all team members.

Scrum introduces short development cycles known as sprints, which help a team to:

• Achieve quick results
• Ensure process transparency
• Adapt to new project requirements, conditions, etc.

Here’s how you can apply Scrum to a driver development project:

1. Create a product backlog. At the start of each iteration, PMs gather, develop, and prioritize all functional and non-functional product requirements. Since the goal of Scrum is to release a product version as soon as possible and improve it in further iterations, your PMs don’t need to elicit all project requirements at this stage. Instead, you can break the project down into several major stages and focus on one at a time.

For minifilter driver development, PMs can use the following stages:

• Development of the driver’s core structure
• Implementation of core functionality
• Log transmission development
• Quality assurance and bug fixing
• Integration with the client’s service

Creating a backlog for a driver development project is a complex task that requires a project manager to analyze requirements, research similar products, and benchmark competitor products to know which tasks to include in one iteration. At Apriorit, we use our experience of previous driver development projects to quickly create a backlog and adjust it for current project requirements to improve its accuracy.

2. Plan iterations. When the product backlog is ready, the PM should divide it into iterations, or sprints, which can last from one to four weeks. A project manager chooses the duration of an iteration for each project based on:

• Type of software
• Time required to deliver a working software version
• Type of cooperation our client has chosen
• Size and lineup of the project team

Dividing a project load into sprints helps a project manager control and improve team performance.

3. Develop the driver. The development team starts writing code and completing tasks planned for a sprint. At this time, the PM overviews the team’s progress, gathers performance metrics, and helps the team reach sprint goals. For example, a project manager closely monitors parallel tasks that depend on each other. They make sure that developers don’t slow each other down with such tasks and complete them on time.

It’s important for a project manager not to micromanage the team at this stage. While developers may need the PM’s help with some issues, they should be focused on development tasks, not meetings and reporting.

4. Test and integrate the driver. An Agile approach dictates that all development tasks should be completed, committed to the master branch, and tested at the end of an iteration. A project manager makes sure the team does that. 

In some cases, developers can’t upload and test their code by the end of an iteration. A PM helps developers manage such tasks and makes sure they continue working on such tasks in future iterations. We’ll examine why this happens later.

5. Review the iteration. The final stage of each iteration is devoted to reviewing the team’s progress, identifying issues, and demonstrating sprint results to our client. In driver development projects, it isn’t always possible to demonstrate a working demo, but at Apriorit, we strive to at least show our client the code we’ve developed during an iteration.

A retrospective at the end of an iteration helps the project manager create a realistic plan for the next sprint and assist the team in resolving discovered issues. 

When one iteration is finished, the project manager starts a new one with the same stages. The cycle continues until the software satisfies the client’s requirements.

Let’s take a look at the pros and cons of using Scrum for driver development.

Key advantages of using Scrum are:

• Quick project start. Scrum is focused on delivering the first development results as soon as possible, so you don’t need to wait a long time to see how your driver takes shape. 
• Easily adaptable to changes. Though driver and kernel development projects rarely change in the middle of the process, Scrum helps the team adjust and quickly implement changes.
• Continuous improvement of team cooperation. Thanks to reviews and retrospectives at the end of each iteration, the project team can quickly resolve their issues and deliver consistent high-quality performance.

However, you also need to take into account the major disadvantages of Scrum in driver development:

• Lack of detailed planning. Scrum prioritizes planning each iteration over planning the whole project. In driver development, such an approach can introduce issues at early iterations that can be difficult to fix at later iterations (such as the wrong architecture or security flaws).
• Challenging progress tracking. Driver development projects can include tasks that require several iterations to complete. It can be challenging to assess project progress because of such tasks.
• Issues with cross-functional teams and parallel development. Tasks in a driver development project are tightly connected. This can make parallel work challenging, as several team members may need to work with the same piece of code at the same time.
• Inability to deliver a working version during iterations. It can be impossible to deliver a working version of a driver at the end of each iteration because a driver is a complex piece of software that won’t work correctly until it has all the needed elements. Because of that, it’s not always possible to write, integrate, test, and present code during one integration.

In our experience, a skilled project manager can mitigate Scrum’s disadvantages and benefit from its advantages. When working on a driver development project, Apriorit PMs pay a lot of attention to balancing quick iterative development and strategic planning. They distribute the workload between developers to make sure each team member can efficiently contribute to the project.

2. Using Waterfall for system programming

Waterfall is an Agile development methodology that divides development into stages. Each stage, from planning to delivery, must be completed before the next one starts. Waterfall generally fits projects that have clear and unchanging requirements and allows a PM to plan the project workflow and cost in detail. 

Here’s how this methodology works in our sample driver development project:

1. Define requirements and plan the project. In the first stage, a project manager collects and analyzes functional and non-functional project requirements. They create a software requirement specification (SRS), which defines all aspects of the driver. This document serves as a foundation for other documentation and provides the project team and stakeholders with a united project vision. 

When the SRS is ready, the PM and the development team:

• Design the driver architecture
• Draw up a detailed development plan
• Assess project risks
• Calculate estimates for each task and the project’s cost

2. Develop the driver. The project team gradually develops the driver task by task according to the plan. Since there are no short iteration and midterm performance assessments, at Apriorit we use earned value analysis (EVA) to analyze team productivity at this stage. EVA helps our project managers assess project progress with metrics, calculate compliance with estimated deadlines and the budget, and predict when the project will be completed. 

3. Test and fix the code. When development is completed, QA specialists test the driver to make sure it meets the requirements defined in the SRS and return a list of bugs to the development team. After fixing these bugs, the team re-releases the driver for re-testing. Quality assurance and bug fixing can be done in parallel, but the cycle continues until the team makes sure that the driver satisfies all of the client’s needs.

4. Deliver the solution. The team demonstrates the product to the client and waits for the client’s approval. 

Let’s analyze the pros and cons of Waterfall for driver development.

Major advantages of Waterfall for driver development are:

• Detailed project planning. With Waterfall, project managers and developers can plan all their activities before they start coding and avoid planning errors such as choosing the wrong architecture and third-party services.
• Exact deadline and budget estimations. Detailed planning and task descriptions help a project manager calculate and provide clients with exact estimations.
• Simple project management. After the initial planning stage, a project manager only has to assess the team’s progress and intervene if the development team encounters issues or the client wishes to change project requirements.

Here are the key disadvantages of applying the Waterfall development methodology to driver development:

• Long project start. Compared to Scrum, Waterfall-based projects take a lot of time before development starts and the client can see results of the team’s work. 
• Lack of project planning flexibility. Once the first stage of the project is completed and all documentation is agreed upon, making changes to the project is challenging and time-consuming.
• Absence of early client feedback. Early feedback helps a project manager adjust project requirements and guide development efforts in the right direction. In Waterfall, there’s no early product version to show to the client and therefore no way to get feedback.

Most of these disadvantages come from errors in project planning. That’s why at Apriorit we carefully elicit and analyze project requirements and conduct technology research before we start coding. We make sure that we understand the client’s vision of the project and clearly reflect it in the documentation.

3. Combining Scrum and Waterfall

As you can see, neither Scrum nor Waterfall is ideal for driver development. Strictly following one management approach means accepting all of its risks and disadvantages. That’s why we try to combine Scrum and Waterfall to get the best of both approaches. Merging several management approaches to fit your project better is also called hybrid project management. 

Let’s examine how such a combination can work.

1. Define requirements. Unclear requirements at the start of driver development lead to severe errors and costly rework. To address this issue, at Apriorit, we apply the Waterfall approach to this stage. A project manager carefully studies the requirements and documents them in the form of a technical specification. 

2. Plan the project. This stage of the project is also governed by Waterfall principles. The PM divides the project scope into iterations (where possible) and plans development stages for tasks that can’t be iterated. Iterations are planned with more attention to details compared to a pure Scrum approach.

3. Develop the driver. The development process combines features of both Scrum and Waterfall. While some parts of the project are divided into consecutive stages and some are done in iterations, all follow Agile principles and values. A project manager ensures process transparency and facilitates team communications.

If new requirements appear at this stage, the PM also manages them according to Agile approaches. After each iteration, the PM can change the plans to accommodate new requirements. As for Waterfall-based projects, Apriorit PMs also uses EVA to evaluate project progress and team performance during development.

To avoid micromanagement at this stage, we use short standup meetings. They help a PM to control the project while taking only 15 minutes of developers’ time.

4. Test the driver. This stage of the project is dedicated to testing the parts of the driver finished during an iteration. If there are no finished parts, QA specialists prepare test documentation or other QA-related activities they’ll need in the future. For example, they can work on early test design, which helps them start testing as soon as developers finish their tasks.

5. Conduct a retrospective. In the case of driver development, we can’t show a working version of the product between iterations. However, the project manager can still conduct retrospectives and sprint reviews to improve the development process and help the team maintain high performance.

Such a hybrid approach to managment can help you create clear and detailed driver development plans while keeping the project flexible and open to changes.

Conclusion

Kernel and driver development is a specific subset of system programming that is hard to manage with out-of-the-box Agile methodologies and practices. A project manager has to adapt the Agile approach of their choice to the project’s requirements and characteristics. This way, the PM can help the development team deliver the driver that fits the client’s requirements and agreed deadlines.

At Apriorit, we always adjust Agile and hybrid project management approaches to the requirements of a particular project. This allows us to pay attention to project requirements and documentation and minimize the risk of deviation from initial requirements. It also helps keep the project flexible and open to new requirements.

Let’s discuss how we can help you navigate your next complex driver development project!