As Local Orbit develops new processes and features, we focus on incremental change and continuous iteration. This means that we add new components into our processes and our application without disturbing anyone’s business, including our own. This way, we can use continuous small actions to effectively solve big problems. This happens throughout the company and the businesses we work with, but in this post, I’ll be focusing on how we implement this strategy in Local Orbit’s engineering work.
Progression ©Bruce Berrien
Earlier, I wrote about the process of developing a new feature on the Local Orbit engineering team. That’s a high-level view of the process. I’ll zoom in to show why it’s always important for us to take things one step at a time. Incremental change in the code itself, and the application structure, allows us to implement change gradually and thoughtfully, both for Local Orbit software developers and the users of the software we build.
In the process of developing a feature, our engineering team focuses on layering in new elements without disturbing existing business processes, and we add new small structures into the code regularly, such that we can iteratively build and test small pieces of new functionality.
For example, last year, we released brand new order and product pages, allowing customers to list multiple units for the same product. Within the code, this multi-unit functionality is supported by a bunch of complex structures and relationships, but by the time customers could see and use this feature, the engineering team had been layering in incremental pieces for some time.
We set up a data structure that could support either single-unit or multi-unit products, even though all products offered through our system at that time had only one unit each. Then we built each new piece of user interface (UI) in the application that was necessary for customers to use the multi-unit functionality — but did not make these UI additions available to anyone until they had undergone testing and iteration on their own. Finally, we completed the integration of the UI to add and edit products with multiple units, and we released the feature to customers with information about how it worked.
Testing among the team does not replace feedback from real users with a diverse set of priorities. However, our incremental, iterative development process allows us to stress-test major parts of new functionality without disrupting our users, or requiring them to learn new processes over and over. By the time we released multi-unit product functionality, we were well prepared to address user feedback that came our way, and the entire development team had an understanding of how the pieces fit together. We had each worked on a different part of integrating the new functionality into our existing system, or had assisted with testing and data architecture.
For the technical development team, this type of incremental, iterative development allows us to maintain steady progress on big features — efficiently meeting the evolving needs of our customers with a small development team. Our engineering strategy is consistent with the overall strategies of the company, and how Local Orbit works to help solve complex, multi-faceted supply chain problems. We’re more successful when we break problem solutions into incremental, well-organized steps.