Folding Tradeoff Space

automation changes the rules we play by

Fast v Safe

Tradeoffs are a fact of life. Choose between safety and speed, stability and flexibility. More of one sacrifices the other.

fast or safe, we are somewhere on that spectrum

I remember a time when this described our decisions about software deployments. Deployments caused problems, so we did fewer of them.

Then came Continuous Integration and Continuous Deployment. With a lot of work, we get automated tests and monitoring, automated deployment and rollback. Then we learned that small deployments are safer — so much safer that many fast deployments added up to less danger than one bulk deployment.

Fast and Safe

It’s like, this automation plus culture change has folded space — these arrows now point in the same direction.

fast and safe point in the same direction, they are no longer in conflict

Bending tradeoff space like this wasn’t free.

Tests double our application code, and infrastructure adds even more code. Harder: we had to change the culture. Think in smallest shippable units. Alleviate the next bottleneck after deploys aren’t it, and the next.

Without weeks of manual testing, we had to create new ways to answer “Does it work?” Without ops people standing by, we needed new ways to answer “is it up?” When each person makes deployment decisions individually, they need tools to support the decision with visibility, and tools to implement the decision with fast rollback in case of surprise.

This automation is expensive, but we wouldn’t go back to the old days of dangerous, slow deployments.

Flexible v Consistent

I want to talk about another tradeoff space, this one in “Do we create custom internal software?” As a business, I want internal software to increase the consistency, legibility, and speed of my employees’ work. We think of the cost of software in terms of money and time, work to create it and to keep it happy. There’s a deeper cost to the organization, though: ossification.

spectrum of flexible or consistent

The consistency enforced by software is great for managers and administrators; they get legibility, meaning they can track work at a high level. These are the people making decisions about software requirements.

I once worked on workflow tracking software for a research organization. The heads of the development effort bragged that they’d encoded the knowledge of the scientists, so they could leave and we’d still have it. The research could proceed… in exactly the same way. Any substantial change took (this is extreme, but it was ten years ago) eighteen months to roll out. So much for scientific innovation! oh but it was great for the higher-ups tracking progress of each experiment as it moved through this regimented system.

This consistency is not optimal for learning, not for daily patient care or customer service. People are adaptable, but software inhibits this adaptation. Ask any nurse, social worker, or hotel receptionist how they feel about the software they have to use. (Ask them when they are off duty.) They’ll tell you about frustrations, time wasted, obstacles to doing great work.

Compared to a paper form, an electronic form is constraining. Compared to talking to each other, coordinating via task trackers is limiting. Software ossifies processes. It impedes learning and improvisation.

Flexible and Consistent

How could we fold this tradeoff space?

This tradeoff exists when the people using the software can’t change the software. Maybe it can help to look at one place where this tradeoff does not exist, where it is naturally folded.

flexible and consistent in the same direction: local automation

When the users are also the system movers, calcification doesn’t happen.

Software teams developing for themselves gain consistency, legibility, speed and more — while adding flexibility. When deployment is automated in one place, we can improve the process without the work of disseminating information.

Automation helps with testing. It helps with deployment. What else can we automate for ourselves? feature tracking, dependency updates, information gathering, project creation, common code change tasks?

Automation isn’t cheap, but it is priceless. Let’s smooth our own work with comprehensive automation. We might even get better at moving systems and help the whole business flex.