One of the principles of DevOps is that you should be able to deploy regularly, with smaller low-risk changes. This addresses a key problem that I see in many sites:
- Each code release is large
- The code is difficult to test
- Code merges are painful
- Deployments take a long time
- Deployments often fail
- Deployments are considered to be high-risk procedures
The end result of this situation is that deployments are avoided and then a snowball effect occurs where:
- The code is even larger
- Code merges are even more painful
- The deployments take even longer
- The deployments are even more likely to fail
- Deployments are considered to be even higher-risk procedures
It's critical to work out how to break this cycle of pain. Smaller changes that are deployed more regularly is often the desired outcome.
But while regular deployments are helpful, so many teams leave performance (and specifically load testing) until way too late.
One of the challenges of my work is that my first involvement with many of these sites is when things are already in a tragic state and the regrets and blaming start:
The worst I've ever seen was a start-up team that was building a new software as a service app. They needed 1000 concurrent users to have a viable business. 5000 concurrent users would be a wonderful business. But after building it for 4 years, and with less than 2 weeks before they needed to show it to the shareholders, they couldn't get it past 9 concurrent users.
Another team was building an appointment application for a government department. They had built the entire logic on layers and layers of untestable triggers, and some triggers performed a very large number of actions. They could never get the application out of User Acceptance Testing (UAT). What was disappointing is that at that stage (long after it should have already been delivered to the customer), all they were hoping for was to find the minimal enhancement that would just get them over the line for delivery.
That's really sad for the customer involved. If they don't accept the app, they have a business issue. If they do accept it, they've bought a lemon.
Ongoing, they're going to hate that app.
Load testing needs to be part of the routine development cycle of any app, and not just left to the end. Even if you haven't made large changes to the app that you're building, no doubt you have dependencies on other code or services, and any of those dependencies could have regressed.