Updates to Versioning Engine

Mike's Notes

This week's changes to the Versioning Engine (ver).

Resources

References

  • Reference

Repository

  • Home > Ajabbi Research > Library >
  • Home > Handbook > 

Last Updated

16/10/2025

Updates to Versioning Engine

By: Mike Peters
On a Sandy Beach: 16/10/2025

Mike is the inventor and architect of Pipi and the founder of Ajabbi.

The recent UI workspaces work necessitated changes to Pipi's Versioning Engine (ver). That engine's data model was changed.

Objects that can change

  • Industry models
  • Industry Schema
  • Workspace UI's
  • User training material
  • Developer Documentation
  • Etc

Versioned namespaces

Every object has a versioned namespace. When a logged change to an object occurs, the Pipi Build Number increments.

On any day, if there is one or more changes to the Build Number, the daily Patch Release automatically increases by 1. The changes are then published in the Changelog.

Minor Release

On the second Friday of every third month, the Minor Release increases by 1. A big picture summary of the preceding three months is published in the Changelog.

Objects in sync

Changes to the workspace UI, developer documentation, user training materials, and related materials need to be kept in sync.

DevOps

Making sure that the recently added DevOps Engine (dvp) runs this sync process might work. It could be done using workflows.

Summary

The engines involved are 

  • Versioning
  • DevOps
  • Learning Object
  • Workspace
  • CMS

Mixins and CFML

Mike's Notes

Pipi needs multi-inheritance, so how?

Modelling nature and complex systems requires multiple inheritance, but CFML does not support it. Here are some initial notes on figuring out what to do. I discovered some possible solutions on Ben Nadel's blog.

Thank you, Ben Nadel.

Resources

References

  • Reference

Repository

  • Home > Ajabbi Research > Library >
  • Home > Handbook > 

Last Updated

15/10/2025

Mixins and CFML

By: Mike Peters
On a Sandy Beach: 15/10/2025

Mike is the inventor and architect of Pipi and the founder of Ajabbi.

When building Pipi 4, 20 years ago, I once wrote to software architect  Sean Corfield asking how to implement multiple inheritance in CFML.

He replied, "Multiple inheritance is bad".

I'm using a database-driven workaround based on BORO at the moment, which works. The thing is, I need a better way to implement multiple inheritance in code.

This morning, for no real reason, I did a Google search for

"cfapplication multiple inheritance cfml"

And discovered what Ben Nadel came up with. He uses CFInclude to create a mixin.

From Wikipedia

"In object-oriented programming languages, a mixin (or mix-in) is a class that contains methods for use by other classes without having to be the parent class of those other classes. How those other classes gain access to the mixin's methods depends on the language. Mixins are sometimes described as being "included" rather than "inherited".

Mixins encourage code reuse and can be used to avoid the inheritance ambiguity that multiple inheritance can cause (the "diamond problem"), or to work around lack of support for multiple inheritance in a language. A mixin can also be viewed as an interface with implemented methods. This pattern is an example of enforcing the dependency inversion principle."

From Ben Nadel on 2013-06-07 

A couple of months ago, I read Practical Object-Oriented Design in Ruby: An Agile Primer, by Sandi Metz. I haven't reviewed the book yet, but I wanted to explore one of the concepts Metz talked about: Ruby Modules. From what I understood (and this may be somewhat off-base, I'm not a Ruby programmer), a module is a way to "inherit" behavior without using classical inheritance. Essentially, behavior is "included" into a class, rather than "inherited" into a class. In a language that only allows for single-class inheritance, a Module provides a mechanism for including behavior from several different sources. Furthermore, it allows the developer to borrow behaviors without worrying about the "is-a-type-of" inheritance relationship. It seems fairly interesting, so I wanted to see how this kind of behavior could be used in ColdFusion."

Code Sample

From https://www.bennadel.com/blog/1551-exploring-mixins-and-coldfusion-components.htm

<cfcomponent
output="false"
hint="I am a component whose methods are created via Mixin methodology.">

<!--- Include the mixin UDFs in the pseudo-constructor. --->
<cfinclude template="public_udf.cfm" />
<cfinclude template="private_udf.cfm" />


<cffunction
name="Init"
access="public"
returntype="any"
output="false"
hint="I return an initialized object.">

<!--- Return THIS reference. --->
<cfreturn THIS />
</cffunction>


<cffunction
name="GetVariables"
access="public"
returntype="any"
output="false"
hint="I return the private scope of this component.">

<cfreturn VARIABLES />
</cffunction>

</cfcomponent>

Ben's blog posts go into much more detail. I will need to experiment and test. Maybe a combination of the existing Boro datamodel and this code might work. It adds a lot of complexity and could be a maintenance nightmare, but with Pipi managing it, it should be OK. Pipi runs on complexity.

Summary

The CFinclude can go in the CFcomponent and/or the CFfunction.

Producing a Better Software Architecture with Residuality Theory

Mike's Notes

Very interesting. Read the references and watch the talk.

Resources

References

  • An Introduction to Residuality Theory: Software Design Heuristics for Complex Systems by Barry M. Barry O'Reilly. 2020.

Repository

  • Home > Ajabbi Research > Library > Subscriptions > InfoQ
  • Home > Handbook > 

Last Updated

14/10/2025

Producing a Better Software Architecture with Residuality Theory

By: Ben Linders
InfoQ: 07/10/2025

Ben Linders is an Independent Consultant in Agile, Lean, Quality and Continuous Improvement, based in The Netherlands. Author of Getting Value out of Agile Retrospectives, Waardevolle Agile Retrospectives, What Drives Quality, The Agile Self-assessment Game, Problem? What Problem?, and Continuous Improvement. Creator of many Agile Coaching Tools, for example, the Agile Self-assessment Game. As an adviser, coach and trainer he helps organizations by deploying effective software development and management practices. He focuses on continuous improvement, collaboration and communication, and professional development, to deliver business value to customers. Ben is an active member of networks on Agile, Lean and Quality, and a frequent speaker and writer. He shares his experience in a bilingual blog (Dutch and English) and as an editor for Agile at InfoQ. Follow him on twitter: @BenLinders.

Software architecture is tough because it blends coding, math, and business systems. Due to surprises, architectures tend to become irrelevant over time, Barry O’Reilly said at Goto Copenhagen. He presented residuality theory, where he suggested stressing naive architectures to reveal hidden "attractors" in complex business systems. This allows designs to better survive change and uncertainty.

Software architecture is difficult because it requires a broad skillset, O’Reilly said. We have to master the world of code, math, and logic, and the world of human and business systems, and understand how these two relate to and affect each other.

At university, they only teach us the tech. When we start to design systems, we realise that the complexity of the business environment constantly surprises us, rendering our architectures irrelevant, O’Reilly said. Making something as static and rigid as a software architecture survive in a fluid world that is always changing is not an easy task, he added.

Residuality assumes that a random simulation of stress on a naive architecture will produce a better architecture than the traditional methods around requirements engineering, risk management, or reacting to change as it happens, O’Reilly explained:

This started out as a curious observation, and for the last 10 years, I have had to build theoretical explanations and experiments to show that this actually is the case. Armed with this knowledge, we can think differently about software architecture and build new tools.

As students of Western science, our first recourse is to reduce any complex system to its component parts and study those parts in detail. This is the default for software engineers, O’Reilly said. In complex systems, the number of elements and potential interactions and states makes this kind of detail-oriented analysis impossible. Previous generations of architects have tried to reduce the complexity of the business environment to logic, or to structures, or to the development process.

One of the key aspects of complex systems is that they never visit all the possible states that the combination of their elements allows. Instead, the interactions of the elements constrain the system to a very small number of potential states, which we call "attractors", O’Reilly said. A complex business system is therefore not modelled as a number of interaction elements and their relationships, but instead as a number of attractors, he explained:

When we build an architecture, it is these attractors that the architecture must survive in. Attractors therefore provide a much simpler and easier and more pragmatic way of interfacing with the complexity of the environment.

The problem is that we don’t know what the attractors are, but by randomly simulating stress, we can discover many of them, O’Reilly said. If you think back to the major architectural failures you’ve seen, you will see that they mostly fail because they missed attractors, he mentioned.

Residuality theory is a very simple process. Sometimes, people are put off because the theoretical work necessary to prove that residuality works is very heavy, but applying it is easy, O’Reilly explained:

We start out with a suggestion, a naive architecture that solves the functional problem. From there we stress the architecture with potential changes in the environment. These stressors allow us to uncover the attractors, often through conversations with domain experts. For each attractor, we identify the residue, what’s left of our architecture in this attractor, and then we change the naive architecture to make it survive better.

We do this many times and, at the end, integrate all of these augmented residues into a coherent architecture. We can then test this to show that it survives unknown forms of stress better than our naive architecture.

In complex business environments with uncertainty, residuality makes it possible to create architectures quickly instead of chasing down stakeholders demanding specific requirements or answers to questions that are unknown by the business itself, O’Reilly said. It pulls technical architects out of details and teaches them to productively engage with a business environment without the lines and boxes of traditional enterprise architecture, he concluded.

InfoQ interviewed Barry O’Reilly about residuality.

InfoQ: How can we prove that the residual architecture that we created is an improvement over the naive architecture?

Barry O’Reilly: A simple test is to use a second set of stressors to check that our residual architecture survives more unknown events than our naive architecture. You can easily see the similarities between this and the training/testing sets of ML. Residuality theory ultimately states that architectures should be trained, not designed.

InfoQ: What benefits have you seen from residual analysis?

O’Reilly: Senior architects report that it gives a theoretical justification for practices that many had already figured out and a shared vocabulary for teams to talk about architecture. Ultimately, it makes architecture more explicit, better defined, and easier to teach. The result is architectures we can believe in and decision-making that is traceable.

It has its challenges as well. A small number of developers find the jump from the linear, logical, mathematical world we are trained for to the lateral, imaginative techniques very difficult. Residuality is a subject as big as OOP and requires the same amount of effort to learn.

Industry workspace

Mike's Notes

Working notes, subject to change, on building the first workspaces.

This was initially a proof-of-concept thought experiment with the platform to enable the creation of any future workspace configuration. This is now being rapidly built using modular patterns.

This needs to work for users and their learning, developers and their technical documentation, and be consistent with any schema or industry standards.

These configurations are now being imported into Pipi 9, replacing the settings first created in Pipi 6 and 7.

Contact me if you would like to help with early testing.

After two weeks, the testing results have been a great success, and it was discovered that the UI created is actually a thin wrapper. One of many emergent properties exhibited by Pipi 9, found by volunteer testers.

Resources

References

  • Reference

Repository

  • Home > Ajabbi Research > Library >
  • Home > Handbook > 

Last Updated

13/12/2025

Industry workspace

By: Mike Peters
On a Sandy Beach: 13/10/2025

Mike is the inventor and architect of Pipi and the founder of Ajabbi.

Each Ajabbi account type has different SaaS applications.

Issues

  • Use nouns.
  • Singular, not plural.
  • Use standard English industry terms and then translate (i18n).
  • Organised by Account TypeApplications + Settings.

Account Type

There are 7 role-based account types, each with different workspace properties.

  • Agent. For Pipi to self-manage.
  • Developer. For configuring Plugins and building Enterprise or SME workspaces using Pipi objects that can be aliased, recombined, deeply nested, and shared.
  • Enterprise. For a feature-rich SaaS workspace. Requires an attached Developer account for admin config.
  • Personal. For everyone with a username, a password, preferences and personal information.
  • Research. For training Pipi with constraints.
  • SME. For simple sharded apps with minimal customisation and integration options.
  • Temp. For temporary anonymised interactions.

Navigation Outline

This is a very rough default outline being used to build the applications, navigation, etc. This changes most days as lessons are learned from user testing.

  • Agent Account
    • Applications
      • Agent
        • ajx
        • alg
        • api
        • apl
        • aui
        • bor
        • brs
        • cbs
        • cde
        • cfg
        • cgi
        • cmd
        • cms
        • cnd
        • cnf
        • cny
        • cor
        • cpt
        • cpx
        • css
        • cte
        • ctx
        • cui
        • dao
        • dmn
        • dob
        • doc
        • dom
        • dpl
        • dsg
        • dta
        • dvp
        • eml
        • eng
        • fac
        • ffg
        • fil
        • fld
        • fnt
        • ftp
        • fui
        • int
        • iot
        • ips
        • kwd
        • lng
        • lnk
        • lob
        • loc
        • log
        • lop
        • lui
        • mim
        • mle
        • mod
        • mpg
        • msg
        • mta
        • mtr
        • nde
        • nsp
        • nte
        • obj
        • ont
        • oop
        • par
        • pge
        • phl
        • pkg
        • pln
        • plt
        • plu
        • plw
        • prm
        • pub
        • pui
        • rbn
        • rgn
        • rle
        • rls
        • rnd
        • scl
        • scr
        • sgp
        • spt
        • ssn
        • sta
        • sys
        • tem
        • tra
        • trn
        • tsk
        • udt
        • usa
        • usi
        • usp
        • usr
        • var
        • vct
        • ver
        • vfy
        • wai
        • wbs
        • wfl
        • wki
        • wsp
      • As a Platform (v1)
        • Cloud Platform
          • Alibaba Cloud
          • AWS
          • Azure
          • Couchbase
          • Cloudflare
          • Container Hosting Service
          • DigitalOcean
          • Google Cloud
          • Hetzner Cloud
          • IBM Cloud
          • JFrog
          • Linode
          • Netlify
          • OpenShift
          • Oracle Cloud
          • OVHcloud
          • Render
          • Salesforce
          • Tencent Cloud
          • Vercel
          • Wasabi
          • Zeabur
      • Data Centre (v2)
        • Cooling
        • Fire
        • Power
          • Live Power
          • UPS
        • Security
      • Mission Control
        • Status
    • Customer (v2)
      • Bookmarks
        • (To come)
      • Support
        • Contact
        • Forum
        • Live Chat
        • Office Hours
        • Requests
        • Tickets
      • (To come)
        • Feature Vote
        • Feedback
        • Surveys
      • Learning
        • Explanation
        • How to Guide
        • Reference
        • Tutorial
    • Settings (v3)
      • Account
      • Billing
      • Deployments
        • Workspaces
          • Modules
          • Plugins
          • Templates
            • Mission Control
            • Researcher
            • Librarian
            • Training
          • Users
  • Developer Account
    • Applications
      • Config  (v.3)
        • API 

        • Component Class 

        • Design System

        • Engine
          • ajx
          • alg
          • api
          • apl
          • aui
          • bor
          • brs
          • cbs
          • cde
          • cfg
          • cgi
          • cmd
          • cms
          • cnd
          • cnf
          • cny
          • cor
          • cpt
          • cpx
          • css
          • cte
          • ctx
          • cui
          • dao
          • dmn
          • dob
          • doc
          • dom
          • dpl
          • dsg
          • dta
          • dvp
          • eml
          • eng
          • fac
          • ffg
          • fil
          • fld
          • fnt
          • ftp
          • fui
          • int
          • iot
          • ips
          • kwd
          • lng
          • lnk
          • lob
          • loc
          • log
          • lop
          • lui
          • mim
          • mle
          • mod
          • mpg
          • msg
          • mta
          • mtr
          • nde
          • nsp
          • nte
          • obj
          • ont
          • oop
          • par
          • pge
          • phl
          • pkg
          • pln
          • plt
          • plu
          • plw
          • prm
          • pub
          • pui
          • rbn
          • rgn
          • rle
          • rls
          • rnd
          • scl
          • scr
          • sgp
          • spt
          • ssn
          • sta
          • sys
          • tem
          • tra
          • trn
          • tsk
          • udt
          • usa
          • usi
          • usp
          • usr
          • var
          • vct
          • ver
          • vfy
          • wai
          • wbs
          • wfl
          • wki
          • wsp
        • Entity Class 

        • Module 

        • Plugin
          • AddThis
          • Amazon Book
          • Apple Map
          • Apple Music
          • ArcGIS Map
          • Atlassian Analytics
          • Azure Map
          • CloudConvert
          • CodePen
          • CodeSandbox
          • Confluence
          • Elfsight Weather
          • Flightradar24
          • FormBlock
          • GitHub-Embed
          • GitLab Snippet
          • Google Analytics
          • Google Calendar
          • Google Docs
          • Google Form
          • Google Map
          • Google Meet
          • Google Sheets
          • Google Slides
          • Instagram
          • IUCN Threat Status
          • Jira Advanced Roadmap
          • JSBin
          • Jupyter Notebook
          • MailChimp
          • Metservice Weather
          • Microsft Forms
          • NASA Spot the Station
          • NASA Worldview
          • NetSuite Case Form
          • NIWA CO2 Widget
          • NIWA Tide Widget
          • NIWA UV Widget
          • NIWA Weather Widget
          • Odoo Form
          • PDF
          • PostHog Analytics
          • Survey Monkey
          • Trello Board
          • Trello Card
          • TypeForm
          • Vimeo Video
          • Weather Widget
          • Wolfram Notebook
          • Yandex Map
          • Yandex Video
          • YouTube Video
          • Zapier
          • Zoho Calendar
          • Zoho Form
          • Zoom Meeting
      • Tools
        • Build
        • Code
        • Deploy
        • Document
        • Feedback
        • Monitor
        • Operate
        • Plan
        • Release
        • Test
    • Customers (v2)
      • Bookmarks
        • (To come)
      • Support
        • Contact
        • Forum
        • Live Chat
        • Office Hours
        • Requests
        • Tickets
      • (To come)
        • Feature Vote
        • Feedback
        • Surveys
      • Learning
        • Explanation
        • How to Guide
        • Reference
        • Tutorial
    • Settings (v3)
      • Account
      • Billing
      • Deployments
        • Workspaces
          • Modules
          • Plugins
          • Templates
            • Solo
            • Team
            • DevOps
          • Users
  • Enterprise Account
    • Applications
    • Customer (v2)
      • Bookmarks
        • (To come)
      • Support
        • Contact
        • Forum
        • Live Chat
        • Office Hours
        • Requests
        • Tickets
      • (To come)
        • Feature Vote
        • Feedback
        • Surveys
      • Learning
        • Explanation
        • How to Guide
        • Reference
        • Tutorial
    • Settings (v.3)
      • Account
      • Billing
      • Deployments
        • Workspaces
          • Modules
          • Plugins
          • Templates
            • Farm
            • --------
            • Art Class
            • Art Studio
            • Concert Hall
            • FX Studio
            • Set Workshop
            • Theatre
            • --------
            • (To come)
            • --------
            • Earthquake
            • Flooding
            • Volcano
            • --------
            • Club
            • Farmers
            • Union
            • --------
            • Civil
            • Housing
            • --------
            • City
            • Home
            • Hydroelectric
            • Nuclear Power Station
            • Wind Turbine
            • ---------
            • Church
            • Mosque
            • Synagogue
            • Temple
            • ---------
            • Plantation
            • Farm Forestry
            • ---------
            • Gallery
            • Library
            • Archive
            • Museum
            • --------
            • Allied
            • Animal Vet
            • Emergency
            • Family Doctor Clinic
            • Hospital
            • Public Health System
            • Patient
            • --------
            • Crop Farm
            • Plant Nursery
            • Viticulture
            • --------
            • Online
            • School
            • ---------
            • Park
            • Zoo
            • ---------
            • (To come)
            • ---------
            • Urban
            • Model Railway
            • ---------
            • Institute
            • Lab
            • Student
            • ---------
            • City
            • ---------
            • Crew
            • Studio
              • Preproduction
              • Production
              • Post Production
              • Distribution
            • Web Cast
            • ----------
            • City
            • Home
            • ----------
            • Depot
            • ----------
            • City
            • Home
            • ----------
            • To come
            • Captive Breeding
            • Wildlife Park
            • Urban Zoo
            • Marine Aquarium
          • Users
  • Personal Account
    • Applications
        • My
          • Calendar
          • Health
          • Profile
          • Task
    • Customer (v2)
      • Bookmarks
        • (To come)
      • Support
        • Contact
        • Forum
        • Live Chat
        • Office Hours
        • Requests
        • Tickets
      • (To come)
        • Feature Vote
        • Feedback
        • Surveys
      • Learning
        • Explanation
        • How to Guide
        • Reference
        • Tutorial
    • Settings (v3)
      • Account
      • Deployment (1)
        • Workspaces
          • Modules
  • Research Account
    • Applications (v.2)
      • Constraint
        • Algorithm 

        • Ontology
          • HMMS
          • SNOMED
        • Package

        • Primative
          • Space Time
        • Schema

        • Standard

    • Customer (v2)
      • Bookmarks
        • (To come)
      • Support
        • Contact
        • Forum
        • Live Chat
        • Office Hours
        • Requests
        • Tickets
      • (To come)
        • Feature Vote
        • Feedback
        • Surveys
      • Learning
        • Explanation
        • How to Guide
        • Reference
        • Tutorial
    • Settings (v3)
      • Account
      • Billing
      • Deployments
        • Workspaces
          • Modules
          • Plugins
          • Templates
            • Mission Control
            • Researcher
            • Librarian
            • Training
          • Users
  • SME Account
    • Applications
      • (To come)
    • Customer (v2)
      • Bookmarks
        • (To come)
      • Support
        • Contact
        • Forum
        • Live Chat
        • Office Hours
        • Requests
        • Tickets
      • (To come)
        • Feature Vote
        • Feedback
        • Surveys
      • Learning
        • Explanation
        • How to Guide
        • Reference
        • Tutorial
    • Settings (v3)
      • Account
      • Billing
      • Deployment (1)
        • Workspaces
          • Modules
          • Users
  • Temp Account
    • Applications
      • Today
    • Customer (v2)
      • (To come)
        • Feedback
        • Surveys
      • Learning
        • Explanation
        • How to Guide
        • Reference
        • Tutorial
    • Settings (v3)
      • Account (0)
      • Deployment (0)
        • Workspaces
          • Modules

Your Users Aren’t Lazy—They’re Managing Change Overload

Mike's Notes

More thoughtful words of wisdom from IT Revolution.

Resources

References

  • Progressive Delivery: Build The Right Thing For The Right People At The Right Time by James Governor, Kim Harrison, Heidi Waterhouse, and Adam Zimman (IT Revolution Press, November 2025).

Repository

  • Home > Ajabbi Research > Library > Subscriptions > IT Revolution
  • Home > Handbook > 

Last Updated

12/10/2025

Your Users Aren’t Lazy—They’re Managing Change Overload

By: Leah Brown
IT Revolution: 02/10/2025

Managing Editor at IT Revolution working on publishing books and guidance papers for the modern business leader. I also oversee the production of the IT Revolution blog, combining the best of responsible, human-centered content with the assistance of AI tools.

Picture this: A seasoned medical coder sits down at her workstation every morning and flies through insurance claims at lightning speed. Her fingers dance across function keys and the ten-key pad without her eyes ever leaving the screen. She processes more claims in an hour than most people could handle in a day.

Then your team delivers a “user-friendly” modernization of her software. Suddenly, she needs a mouse. The keyboard shortcuts she’s memorized over decades no longer work. Tasks that took seconds now require multiple clicks through dropdown menus. Her productivity plummets.

Is she being resistant to change? Lazy? Unwilling to learn?

None of the above. She’s managing change overload in the only way that makes sense: by protecting the workflows that keep her livelihood intact.

This scenario, shared by coauthor Heidi Waterhouse in the upcoming book Progressive Delivery, illustrates a fundamental misunderstanding that’s costing organizations millions in failed software rollouts, user frustration, and abandoned features.

The Change Paradox

Here’s what seems contradictory but is actually perfectly logical: the same person who eagerly upgrades their iPhone every year might resist a minor update to their work software. The same developer who constantly experiments with new programming languages might refuse to adopt your team’s new deployment tool.

This isn’t hypocrisy—it’s smart change management.

People have a finite capacity for absorbing change. We instinctively protect our most critical workflows while remaining open to improvement in areas where failure isn’t catastrophic. Your iPhone upgrade can be undone or worked around. Your work software, which determines whether you can pay your mortgage, demands much more careful consideration.

Beyond Stakeholders: Understanding Your Full Constituency

Most organizations think about their users as “stakeholders”—people who have a financial or organizational interest in the product’s success. But Progressive Delivery requires thinking about “constituents”—everyone who is actually affected by your software, whether they appear on your org chart or not.

Consider medical records software. The obvious stakeholders are:

  • Doctors who input patient data.
  • Hospital administrators who purchase the software.
  • IT teams who maintain the systems.
  • Your development team who builds features.

But the full constituency includes:

  • Nurses who need to access information during emergencies.
  • Patients who use portals to view their own data.
  • Family members helping elderly relatives navigate health information.
  • Regulatory bodies ensuring privacy compliance.
  • Insurance companies processing claims.
  • Medical billers like our friend above.

Each constituent has different change tolerance levels, different technical sophistication, and different stakes in maintaining stability versus embracing innovation.

The Three Types of Change Capacity

Not all users approach change the same way. Understanding these differences is crucial for delivering software that actually gets adopted:

  • The Builder Mindset Some users see software as LEGO blocks—they want to understand how things work and customize their experience. These are your early adopters who read release notes, experiment with beta features, and provide detailed feedback. They have high change tolerance because they enjoy the process of discovery and optimization. They’re willing to invest time learning new workflows because they see it as creative problem-solving.
  • The Tool Mindset Most users see software as a hammer—they want it to reliably perform specific tasks without requiring constant attention. They’ve developed efficient workflows around current functionality and view changes through the lens of “will this help me get my job done better?” They have moderate change tolerance when improvements clearly align with their goals, but they resist changes that disrupt established patterns without obvious benefit.
  • The Survival Mindset Some users interact with software in high-stakes environments where mistakes have serious consequences. Medical professionals, financial traders, air traffic controllers—these users have optimized their workflows for safety and reliability above all else. They have very low change tolerance because their primary concern isn’t efficiency improvement—it’s avoiding catastrophic failure.

The Cost of Misreading Your Constituency

When you misunderstand your users’ change capacity, you create what Progressive Delivery calls “technological jerk“—the jarring experience of change happening too fast for people to absorb.

Slack’s 2019 redesign perfectly illustrates this mismatch. Slack’s design team saw an opportunity to create a more modern, streamlined interface. They were thinking like builders—excited about cleaner visual hierarchy and improved information architecture. But most Slack users weren’t builders—they were people managing dozens of conversations across multiple workspaces while trying to get their actual jobs done. The redesign disrupted muscle memory, changed keyboard shortcuts, and reorganized familiar layouts. What felt like an improvement to the design team felt like chaos to users trying to maintain productivity.

Sonos’s 2024 app disaster represents an even more dramatic failure. The company released an app update that broke core functionality like sleep timers and queue management. Users weren’t just annoyed—they were unable to perform basic tasks with expensive hardware they’d already purchased. CEO Patrick Spence was forced to resign in January 2025.

In both cases, the companies built better software from a technical perspective but failed to consider how changes would land with people who depended on existing workflows.

The Adobe Alternative: Progressive Control

Adobe provides a masterclass in respecting user change capacity while still driving innovation. When they integrated AI into their Creative Cloud suite, they could have simply pushed the latest models to everyone simultaneously. Instead, they implemented what Progressive Delivery calls “radical delegation.”

Users can choose which AI model version to use for different projects. Someone working on a long-term brand campaign can maintain consistency with Firefly v1, while someone experimenting with new creative techniques can opt into Firefly v3. The same user might make different choices for different contexts.

This isn’t just about offering a “classic mode” checkbox. Adobe created granular controls that let users manage their own change absorption rate based on their specific needs and risk tolerance.

Three Strategies for Respecting Change Capacity

  1. Delegate Control to the Point of Impact: Instead of deciding when users should adopt new features, give them the tools to make that decision themselves. Microsoft’s “Try the new Outlook” toggle lets users test the redesigned experience and revert if needed. Google Workspace offers separate release tracks for organizations with different change tolerance levels. The key is making this choice meaningful—not just a temporary beta flag that eventually disappears, but ongoing control over their experience.
  2. Design for Multiple Speeds Simultaneously: Your power users and cautious users don’t need to move at the same pace. GitHub ships hundreds of small changes that are mostly invisible to casual users but provide meaningful improvements for developers who spend all day in the platform. Meanwhile, major feature releases are carefully communicated and gradually rolled out. This allows your constituency to self-select into the change pace that matches their capacity and context.
  3. Build Reversible Experiences: Make it safe to experiment by making it easy to step back. This isn’t just about technical rollback capabilities—it’s about user confidence. When people trust they can explore new functionality without getting trapped in unfamiliar territory, they’re more willing to try changes. Netflix’s interface experiments are a good example. They test thousands of variations, but users never feel stuck with a version they dislike because the changes are either subtle or easily reversible.

The Empathy Advantage

Organizations that successfully implement Progressive Delivery share a crucial insight: user “resistance” is usually valuable information about change capacity, not character flaws to overcome.

When users complain about the pace of updates, they’re telling you about their bandwidth for absorption. When they create workarounds to avoid new features, they’re showing you that your timing doesn’t match their readiness. When they stick with “legacy” workflows, they’re protecting something valuable that you might not understand.

Instead of viewing this feedback as obstacles to overcome, Progressive Delivery treats it as essential input for delivering software that actually creates value.

The Path to Sustainable Innovation

Here’s the paradox: When you respect users’ change capacity, you can actually innovate faster. Users who trust that you won’t disrupt their critical workflows are more willing to experiment with new capabilities. Users who feel heard and respected become advocates rather than resistors.

Progressive Delivery isn’t about slowing down innovation—it’s about ensuring innovation actually reaches the people who need it, when they’re ready to receive it.

Your users aren’t lazy. They’re not change-averse. They’re not technologically backward.

They’re intelligent people managing complex workflows in environments where stability matters. They’re making rational decisions about where to invest their limited change capacity. They’re protecting their ability to be productive while remaining open to genuine improvements.

The question isn’t how to overcome user resistance. The question is how to build delivery systems that work with human change capacity rather than against it.

When you get that right, everyone wins: users get software that actually makes their lives better, and you get the sustainable adoption that drives real business value.

This post explores concepts from the upcoming book Progressive Delivery: Build The Right Thing For The Right People At The Right Time by James Governor, Kim Harrison, Heidi Waterhouse, and Adam Zimman (IT Revolution Press, November 2025).