How BDB Software is Transforming Flow Cytometry Solutions with Agile Practices

In this article, I will share some of the changes we have implemented or plan to implement at BDB Software to improve our flow cytometry software development and delivery process.

DevOps Pipeline

One of the key aspects of agile software development is to enable fast and frequent feedback loops between developers and customers. This allows us to identify and fix issues early, deliver value incrementally, and respond to changing requirements quickly. To achieve this, we need a robust DevOps pipeline that automates our software's build, test, deployment, and monitoring.

We use state-of-the-art tools that help us to:

• Manage our source code and version control using Git.
• Build our software using continuous integration (CI) and run automated tests using various frameworks such as NUnit, Selenium, and SpecFlow.
• Deploy our software using continuous delivery (CD).
• Monitor our software performance and quality using SonarQube and Azure Application Insights.

Using these tools reduces the time and effort required to build, test, deploy, and monitor our software. We have also increased our software's reliability, security, and scalability.

Test Automation

Another important aspect of agile software development is ensuring our software's quality. This means that we need to test our software thoroughly and frequently to ensure that it meets our customers' expectations and complies with our industry's standards. However, manual testing can be time-consuming, error-prone, and costly. Therefore, we need to automate testing to save time, reduce errors, and increase coverage.

At BDB Software, we have increased our test automation by using tools such as NUnit, Selenium, SpecFlow, Postman, and JMeter. These tools help us to:

• Write unit tests using NUnit to verify the functionality of our code.
• Write integration tests using Postman and JMeter to verify the interaction between our components and services.
• Write end-to-end tests using Selenium and SpecFlow to verify the behavior of our user interface.

By using these tools, we have increased the quality of our software by detecting and fixing bugs early. We have also increased the confidence of our developers by providing them with fast feedback on their code changes.

Self-Upgradable Features

One of the challenges of delivering flow cytometry solutions is that they often require frequent updates to keep up with the evolving needs of our customers and the advances in our industry. However, updating software can be risky, disruptive, and expensive. Therefore, we need to minimize the impact of updates on our customers and maximize the value they get from them.

At BDB Software, we have implemented self-upgradable features in our software that allow us to update them without requiring any intervention from our customers or long downtime for our software. These features include:

• Feature flags: These are switches that allow us to turn on or off certain features in our software without changing the code or redeploying the software. This allows us to test new features in production with a subset of users before rolling them out to everyone.
• Feature toggles: These options allow users to enable or disable certain features in our software according to their preferences or needs. This gives users more flexibility and control over their experience with our software.
• Feature modules: These components can be added or removed from our software without affecting its core functionality. This allows us to provide users with more customization and personalization options for their software.

By using these features, we have increased the agility of our software delivery process by enabling faster feedback cycles, easier experimentation, and safer deployments.

Modularized and Evolutionary Architecture

One of the benefits of flow cytometry is that it can measure many parameters simultaneously from a single sample. However, this also means that the software that supports flow cytometry needs to handle a large amount of data and complexity. Therefore, we need to design our software architecture in a way that can cope with the high demand and variability of our domain.

At BDB Software, we have adopted a modularized and evolutionary architecture approach for our software. This means that we have:

• Divided our software into smaller, independent modules that can be developed, tested, deployed, and scaled separately. This allows us to reduce the coupling and increase the cohesion of our software.
• Designed our modules to communicate with each other using well-defined interfaces and protocols. This allows us to decouple our modules and increase their interoperability and compatibility.
• Evolved our modules over time by adding, removing, or changing them as needed. This allows us to adapt our software to our domain's changing requirements and opportunities.

Using this approach, we have increased our software's modularity, flexibility, and maintainability.

Organizational Structure

One of the agile software development principles is to align the organizational structure with the software architecture. This is based on Conway’s law, which states that “organizations which design systems … are constrained to produce designs which are copies of the communication structures of these organizations”. Therefore, we need to organize our teams and processes to support our software development and delivery goals.

At BDB Software, we have restructured our organization to follow a cross-functional and self-organizing model. This means that we have:

• Formed small and autonomous teams that are responsible for one or more modules of our software. These teams consist of developers, testers, analysts, designers, and product owners who work together to deliver value to our customers.
• Empowered our teams to make decisions about how they work, what they work on, and when they deliver. These teams follow agile practices such as Scrum, Kanban, or XP to plan, execute, and improve their work.
• Encouraged team collaboration and communication using tools like Microsoft Teams, Slack, Zoom, and Miro. These tools help us to share information, ideas, feedback, and best practices across our organization.

Process Changes

One of the benefits of agile software development is that it allows us to deliver software in small and frequent increments rather than in large and infrequent batches. This enables us to get feedback from our customers sooner and adjust our plans accordingly. However, this also means we must change our processes to support shorter release cycles and faster feedback loops.

At BDB Software, we have made several process changes to support our agile software delivery goals. These changes include:

• Adopting a lean and iterative approach to software development. We use techniques such as value stream mapping, user stories, minimum viable products, and retrospectives to identify and eliminate waste, deliver value, and improve continuously.
• Implementing a continuous improvement culture. We use tools such as Kaizen, Gemba, and A3 to foster a culture of learning, experimentation, and problem-solving among our teams and stakeholders.
• Streamlining our approach to characterization, verification, and validation. We use tools such as the design of experiments, risk-based testing, and test-driven development to optimize our testing activities and ensure the quality of our software.
• Aligning our release plans with our customer needs. We use tools such as roadmaps, release trains, and feature branches to plan, coordinate, and execute our releases in a flexible and predictable manner.

By using these changes, we have increased our software delivery process's efficiency, effectiveness, and responsiveness.

Conclusion

At BDB Software, we are passionate about providing our customers with the best flow cytometry solutions in the market. To do this, we are constantly improving our software development and delivery process by changing the organization, the technology, the architecture, and the processes. These changes help us deliver innovation to our customers faster and more iteratively.