It’s the convenient untruth: There is a common misconception that software that is flexible and extensible is also necessarily complex and hard to use. The thinking goes, if a product allows you to extend and customize it, it must be hard to set up and use.
SAP is the classic example of this. Their ERP has long been the archetype of extremely powerful software that can do anything you want. However, lots of time is required from SAP professional services to get it functional within an organization.
On the other end of the spectrum lie most consumer-facing mobile apps. They are simple to use, but generally have limited configurability or extensibility. I can’t program my own extensions for the Strava app on my phone (unfortunately).
This misconception saves product managers, designers, and software engineers a lot of work. If they can make the case that extensibility and simplicity cannot co-exist, it makes their job much easier.
Just because most software products lie on the line in the graph above does not mean that it is impossible to create a product that is both easy to use and extensible.
When Auggy da Rocha and I founded CloudBolt, we did so with the specific intention of building a product that was both usable out-of-the-box without any customization, but that also allowed more advanced administrators to customize the product to look and act exactly the way required for their organization. Achieving both of these simultaneously was not easy, and did not come for free, but we knew that this combination of attributes was necessary to provide a solution customers would love.
When we in the software industry get past the misconception that simplicity and flexibility cannot co-exist, we find it’s an intriguing and worthy challenge to figure out how to achieve both at once.
Simplicity and powerful extensibility are not unrelated, but they can be independently improved and evaluated. Here’s a better way to visualize the graph above:
I propose that we hold software to a higher standard, and that we use this list of attributes as a scorecard to help in the evaluation of software. This scorecard is also valuable for software development teams to evaluate the quality of their own software, and to strive for improvement. Though these attributes are focused on enterprise software, they are applicable for many consumer-facing products/services as well.
The 11 Attributes of Extensible & Consumable Software
- One can set up a new account (or, if on-prem, one can install the product) in 30 minutes or less
- Value seen within the first hour of use
- Full external-facing API
- The product’s UI uses the user-facing API exclusively. In other words, the UI does not depend on any API calls or interfaces that are not documented and available to customers.
- Authentication is customizable within the product’s UI
- The UI has a customizable look & feel
- The UI can be extended with custom modules
- Back end logic that can be extended with custom modules in various hook points
- Customizations & extensions are upgrade-safe
- Full documentation and support for the API, extension framework, and hook points
- Rich library of readily-available examples of extensibility
Techniques for Achieving All 11 Attributes
Some tips on how to achieve more of the attributes above:
- Setting up a public location with many extensibility examples. At CloudBolt, this takes the form of public github repository (called the CloudBolt Forge) and a CloudBolt server (called the CloudBolt Content Library), which each installation of CB knows how to query and display available examples so that users can browse extensions and find one to start with.
- Include time into the software design and implementation schedule to build the right API for new features, build a simple UI, and also make the feature extensible & customizable.
- If you do not have sufficient time to make it easy and extensible, start with extensibility, and schedule a project to make it easy in the immediate next release. This is a more specific incarnation of Ken Beck’s rule for software: “Make it work, make it right, make it fast. ” One example of this within CloudBolt is synchronizing user permissions. We had very little time to get this feature in initially, so we just exposed a new hook point at the time users log in which allowed customers to write their own synchronization logic, starting with some examples we provided. Not long after that, we followed up with a full UI for configuring synchronization of user permissions that obviated the need for looking at or changing any code.
- Collaborate in brainstorming. Get a group of creative people together around a [virtual] whiteboard, throw around ideas good and bad for ways to make the software both customizable and easy to use. You may be surprised at what you’re able to come up with together, and at how fun it is.
- Use the extensibility framework internally! Any time a new feature needs to be developed, ask the question: what if we had to implement this without any changes to the core product code, just using the extensibility framework. If it’s too hard, the extensibility of your product could use improvement.
- Constantly ask what the easiest way to provide customizability and extensibility would be. Instead of making the customer learn a domain specific language (DSL), could we allow them to program extensions in a language they already know? Instead of requiring them to code from scratch, could we give them a working chunk of code and then let them change it to meet their needs? Or, instead of requiring them to code, could we create a configuration UI for customizing the product?
Today, IT professionals have precious little time to administer enterprise systems, but they are also expected to integrate many of them with each other, and also to customize each. Only through enterprise software solutions that are simple to use and administer, and also easy to extend and customize, can we empower IT professionals to succeed in their work. The importance of delivering software that achieves this combination of attributes previously thought to be incompatible is growing constantly, with rising user expectations and the proliferation and heterogeneity of systems that need to be managed.