How to maintain viable applications so that they continue to deliver value in the long term?
Are your applications and services utilized to their full potential? Are you even aware of how they’re performing? If you want to know how well they could be doing, you’ve come to the right place. This blog will tell you all you need to know about caring for your application to give it a long and healthy life.
Over the past year those of us on the application management team have been sinking our teeth into improving our processes and looking for the best tools and practices to help our customers. We have now reached the point where we want to share our findings with you and in this blog series we’ll show you how to get the most from your applications.
This is an introduction to the overall process and methodology we follow at Eficode’s application management. Our main focus is to ensure and improve the quality and maintainability of long-term software solutions.
Application management is necessary for tackling a range of problems that build up over time. These are usually manifest as deficiencies in quality, information security, documentation and automation, and they undermine the efficiency of operations. Any one of these issues can result in significant long term costs unless you are proactively identifying them and fixing their root causes. The problems we find our new customers struggling with are commonly caused by one or more of the following challenges:
- Lack of time and resources to maintain and develop the systems.
- Insufficient knowledge of application architecture and its management.
- Poor communication within the organization and/or between suppliers.
Get onboard and enjoy the ride!
To be or not to be: That is the audit!
Before we jump into managing the applications of new customers, we want to take a look at what’s ahead of us. Also, to avoid buyer’s remorse, we highly recommend conducting a maintainability audit to evaluate the current state of the software system.
It’s almost like going to the dentist for a checkup (but much more pleasant). If you’ve neglected this duty for a while there will likely be some unpleasant discoveries. We audit the current system to determine the viability of the service and point out the main areas for improvement. Our aim is to improve the efficiency of application management and focus the available resources and efforts to continuously improve the system.
You won’t feel a thing, I promise!
The maintainability audit is typically conducted by interviewing key personnel, such as the product owner and technical experts, and by reviewing the existing documentation and codebase. Our specialist investigates the application to form a view of the overall technical state of the software. Simultaneously, the results shed light on how DevOps and automation can boost the customer’s business. The focus and the scope of the maintainability audit typically considers software development related technologies and processes, version management, integrations, usage of DevOps tools, level of automation, documentation, technical risks, and our recommended support model. That being said, the scope can be adjusted in case there are specific points of interest.
The maintainability audit is a cost-efficient way of getting professional feedback on the software and provides support to form an action plan for the future. We gain important insights on the options that are open without risking vendor lock-in. And should the customer decide to trust their systems in our care, the audit helps to prepare for the handover project. After the audit we present a written report containing the results, key observations, and our improvement suggestions.
Now we know what we are dealing with, we can move on to a brighter future. A handover is implemented to smoothly transition the system to Eficode’s application management. The maintainability audit, together with the handover process, provide a clear roadmap for the future of the system.
Thank you for trusting us with your investment! We will take good care of her!
A handover is sort of like renting an apartment. Before you move you do the paperwork: redirecting your mail, transferring your electricity and broadband contracts, packing your belongings, and hiring a moving company (or bribing your friends with beer and pizza like a true cost-cutting pro). Without any preparation or planning, you’ll be in the new apartment sipping on warm beer in the dark, marveling at the magnificent silhouette of your poorly organized Everest of possessions. Being well prepared is half the battle, right?
Hiding from the problems brought on by bad planning
A well-planned and executed handover helps in all the later stages of application management. Conversely, if the handover is executed poorly, problems will occur. Typically, issues might be as simple as not having the necessary access rights to a service. But, on a more serious note, knowledge on how to operate the service or how to recover from exceptions might be completely lost.
When starting the handover, our team is granted access to the services and servers. This is followed up with knowledge sharing and getting to know the system. If we’ve done the maintainability audit we will already have a lot of the necessary information, and we’ll work towards deepening and spreading the knowledge between the team members. If the audit has not been conducted we’ll allocate more time to investigate thoroughly.
To complete the handover, the software system is fully transitioned under Eficode’s control. As a finished product, a roadmap of improvement suggestions related to environments, development pipelines, technologies, and recognized customer needs is written. Monitoring is set up and communication channels and the practicalities of day-to-day work are agreed upon. Lastly, the support contract is signed to put us in control of maintenance and further development.
Now the software reaches Eficode’s application management. We then work to ensure that the future of the software is brighter, no matter how it got here. A fellow Eficodean posted a blog about the pitfalls of the project mindset a while back, stating that You need to think about your software with an infinite mindset. Using our expertise and experience to guide the application so that it remains viable and in use for years to come while continuing to produce value is what we strive for.
Forget about the project mindset
Projects, by definition, have a clear beginning and end - or at the very least an agreed scope. Software, on the other hand, does not. The end-users don’t disappear (hopefully) when the initial implementation project has been completed. Whatever we do, we do with long-term benefits in mind.
Automate the testing!
Maintaining adequate test coverage is something that most of us agree is of utmost importance for quality assurance, but this can sometimes be forgotten (or just blatantly ignored) when important deadlines are approaching. Catching bugs later on can be a daunting task, not to mention more expensive. Setting up and maintaining test automation ensures that the test suite stays up-to-date. This supports further development and means new developers can be swiftly incorporated into the project.
The benefits of test automation are uncontested. With test automation you can be sure that building new functionalities doesn’t break existing code. The need for manual testing is minimized for both the developers and customers. In our experience, manual testing is time-consuming and quite frankly error prone and boring, whereas computers never find repetitive tasks dull. Therefore, it’s best to let computers do as much of the testing as possible to free humans for more innovative tasks.
You better hope that expanding the building doesn’t break the foundations!
Upgrades and dealing with technical debt
Keeping the software and firmware versions up to date is a never-ending process. Ignoring this responsibility will inevitably lead to issues with information security. In addition to keeping things secure the benefits of this include improvements in usability, performance, and even access to new features.
Continuous quality improvements, including refactoring
With code we follow the boy scout rule, “Always leave the code better than you found it”. We continuously improve the quality of code to optimise for readability and performance to enable efficient maintenance of the application.
Upkeeping and improving documentation
Have you ever tried to assemble IKEA furniture without instructions? How about sending a letter without an address? Or trying to guess your friend’s pin code? If you have it’s likely you’ve failed. It may have also crossed your mind that with the appropriate information the task might have been easier and unnecessary steps could have been avoided.
Keeping documentation up to date and available to those who need it increases efficiency. If the documentation is insufficient, whoever tries to utilize it will inevitably run into trouble. It leads to unnecessary interruptions and having to stop ongoing work to assist a teammate with something that could’ve been easily explained in the documentation. Helping out isn’t a bad thing, but it shouldn’t be happening in situations like these.
Bug fixes with reliable resolution time
Contrary to projects where deliveries are mainly related to adding value by producing new functionality, the deliveries in application management may also be due to incident management and bug fixes. Every software has bugs. Software development is a creative process and humans are prone to making errors. Bugs are a natural part of the software life cycle.
Good night sleep tight, we won’t let the software bugs bite!
Malfunctions need to be resolved as quickly as the severity of the situation demands. Sometimes the error may be as small as a misspelled word, but once in a while the error may cause the service to stop completely. The resulting fix is not something that will add new value to the service, but only realigns the functionality back to what was expected in the first place. We strive to learn from our mistakes and for every incident we check that our monitoring and precautionary measures are on the right level.
… 2 years after
So, how does the story continue to unfold? Typically, during the first two years of application management, we’ll have worked on 200 tickets (give or take). The tickets will have handled bug fixes, developing loads of new features, possibly setting up new integrations, and definitely applying security updates and patches. Moreover, we’ll have made sure that the application meets the accessibility requirements required by the law. And if they weren't there already we would have looked at moving the applications to the cloud to enable better scalability and robustness. Success!
I’m so happy I don’t have to worry about my existing software and can focus on the essentials!