skip to Main Content
Back to Insights

The way software is designed is about to change. 

Software design has always been constrained on two fronts: the imagination of the designer, and the tools at her disposal. Until today, the design of software has been primarily informed by the physical world of pens, paper, desks, and filing cabinets. These ideas are profoundly ingrained into the design of even the most modern web applications. Data is entered into HTML forms that replicate paper forms and is eventually stored in databases with rows and columns reminiscent of early, physical ledger systems.

The tools we use to build SaaS applications strongly adhere to this model. The modern web evolved out of the well-known, 3-tier model of a database, application server, and presentation layer. Users entered data in web forms designed to evoke the familiarity of a paper layout. They were rewarded with summary reports and graphs which they could then interpret. Even later iterations of web tooling (Web 2.0, NoSQL databases, and microservices) did not fundamentally break this model. We created and updated data, and read it back in the form of reports. The design of every software application began with these a priori assumptions.

The power of a paradigm is that it becomes so deeply ingrained in our thinking that it is no longer questioned. And so the imagination of software designers has been hemmed in by the tools available to them. The designers building the tools built better UI’s to enter the data (via endless Javascript libraries) and better databases to store the data (in JSON trees rather than tables), but improvements have been incremental so the paradigm remains the same. Using most business software, though, has always felt like work.

Business logic was moved from servers in the cloud (Ruby on Rails), to snappier browser front ends (Angular), then back to the cloud (as serverless functions), and now back to CDN endpoints. But wherever business logic resided, its task was to validate the data that the users entered, to query the databases, and to build the views, graphs, and reports.

Thinking Past the Paradigm

Now, however, the imagination of the best designers has been gripped by twin ideas: 

  • What if we start again with a clean sheet of paper and built intelligent software that does more than process data? 
  • What if we move an entire abstraction up from the data layer and begin to design for users and the tasks they’re trying to accomplish? 

In other words, a software application should no longer simply store and report on data, it should help users accomplish tasks–to make work feel less like work.

We believe that a confluence of three technological trends has made this type of software design possible today and eventually inevitable. A combination of machine learning, deep integration between applications, and ubiquitous sensors now allows software to perceive the world with a new level of intelligence and helps users complete tasks. We’ve written elsewhere about the possibilities and implications of this Intelligent Connected World

Of the three trends, both the rise of machine learning and the ubiquity of sensor technology have been widely discussed and ought to be self-evident. The deep integration between applications warrants a brief explanation.

We have written previously about API’s as connective tissue but have advanced our thinking and now believe that communication between applications will be both deeper and broader: software will increasingly have access to more data provided by other applications, giving it more meaningful context and broader data from which to derive insight. As each application becomes more intelligent, every adjacent application will benefit. We believe that this exponential effect has gone largely unnoticed.(1)

By now, it is common knowledge that compute power doubles every two years and data creation grows even faster. Less well known is that there are discontinuous step changes in the way that compute power is packaged. The form factor of computers persists unchanged for a period of time but then changes dramatically as a new class of computing emerges.(2) Desktop computers with a mouse and keyboard give way to smartphones with touch interfaces. We are now on the cusp of another discontinuity as intelligent software agents begin to proliferate.

Step-Changes in Compute Interfaces

Intelligent Software Agents

Intelligent software agents will have three defining characteristics: 

  • They will be embedded in common objects like mirrors, cars, and fridges 
  • They will be narrowly intelligent and capable of completing well-defined tasks 
  • They will communicate via speech

Software agents will not, in the next few decades at least, be generally intelligent or creative. They will not even have the appearance of general intelligence. Rather, they will be designed to accomplish specific tasks in narrow domains. In many cases, they will assist humans by accomplishing atomic tasks that eliminate drudgery.

There will be two virtuous cycles that will accelerate the spread of software agents over time. First, the longer any software agent is deployed, the more helpful it becomes as it accumulates data and learns to address more problems. Second, as the density of software agents increases, they gain more access to data that is frequently trapped in siloed data systems. Both of these cycles will reinforce the ability of software agents to accomplish their tasks.

Intelligent software agents represent a discontinuity with the past that will change the way software has been designed for 50 years. At Scale, though, we are optimistic about the future of an intelligent, deeply connected world. Harnessing the power of compute and allowing software to automate repetitive tasks and find patterns in data will free people to focus on the creative aspects of work. 

Computers will work for us more than ever before.

(1) State of the art neural networks have approximately the same number of neurons as the brain of a frog. Human brains have three orders of magnitude more neurons.

(2) Roughly every decade a new, lower-priced computer class forms based on a new programming platform, network, and interface resulting in new usage and the establishment of a new industry.


Back To Top