Who will build my app, my website, my enterprise application?

Answer: Nobody. Nobody builds software. I am a developer and I don’t build software.

What am I talking about? How does software come about then? To answer this question, let’s look at a standard product development process.

Product Development

Here’s a high level overview of a product development process.

  1. Design
  2. Build prototype/model
  3. Build/manufacture product
  4. Marketing
  5. Handle orders
  6. Shipping

Whether you’re developing a washing machine or a house, this product development process is broadly similar.

It is usually quite easy to picture the professions involved in each step.

For example with houses, you might imagine something like this:

  1. Design the house - Architect
  2. Build prototype/model - Architect
  3. Build house - Property Developer
  4. Market house - Real Estate Agent
  5. Handle orders - Real Estate Agent
  6. Shipping - Moving Service 1

1. When your product is a house it’s usually more convenient to ship your customers to your product rather than the other way around, although nowadays that isn’t always the case.

Software Development

So which professionals are involved at each step in software development?

(We’ll skip the design step for now, and come back to it in a bit)

Build prototype/model

To think about who builds software let’s think about what software programs are made of. From one perspective, software is literally made of electrons arranged and stored in a computer. Software developers don’t spend their days arranging electrons with teeny tiny tweezers. Arranging electrons is the job of computers. Therefore computers are responsible for building software prototypes.

Developers usually call this version of the software their local/development instance.

When I, as a developer, instruct the computer to build a prototype it does it in seconds, and even tells me if things go wrong, giving me information about what step of the build failed. The computer is so good at producing prototypes that, hundreds of times a day, without a moments hesitation, I will tell the computer to build a prototype of the software I am developing.

Build/manufacture product

This one’s easy. The computer device (desktop computer, phone, what-have-you…) did such a great job of building a prototype, we quite happily let it build the production version of our application.

Typically deploying an app or website involves pushing to and building on a server, and, we’re talking mere minutes for computers to complete this step.


The internet (a collection of connected computers) usually does most of the work again. Search Engine Optimisation expertise and advertising and marketing expertise are often used here, but most of the heavy lifting is done by the search engines themselves: computers.

Handle orders and shipping

When someone wants to receive a web application in their browser or a native app on their phone, they click a button on their screen (maybe pay some money in the case of native apps), and the magical process of downloading begins. Again orders fulfillment for software is accomplished by computers in seconds.

What’s left? Design

  1. Design - ?
  2. Build prototype/model - computers
  3. Build/manufacture - computers
  4. Marketing - mostly computers
  5. Handle orders - computers
  6. Shipping - computers

The only thing computers have left for us poor humans to do (apart from some marketing stuff) is design, and even then computers play a significant role.

Software development as design

So software development from a human perspective is entirely a design process. Humans don’t build software. Humans design software. And computers do almost everything else in next to no time at all

To gain a deeper understanding of software development today let’s compare it to another design intensive business: building design (architecture).

A comparison with building construction and architecture

When designing a building (e.g. a house) there are a number of different roles involved. There are:

  • the building owner who commissions the work and makes decisions
  • architects to produce high level plans to show what the building will look like
  • engineers to provide technical expertise (e.g. “No don’t build it out of cheese”)
  • draftspeople to translate high level plans into detailed technical plans that can be interpreted by the builders

When designing software you have:

  • the product owner who commissions the work and makes decisions
  • designers to produce high level plans to show what the software (e.g. website) will look like
  • developers to provide technical expertise (e.g. “No don’t build it out of cheese”) and to translate high level plans into detailed technical plans (i.e. code) that can be interpreted by the computers who will do the actual building

Both the building design process and the software design process are design intensive, but for completely different reasons.

Buildings are made of expensive materials and take a relatively long time to build, so constructing buildings is expensive, and a design intensive process is employed to get everything right before major costs are incurred.

Software is made of extremely cheap materials (i.e. electrons) and the build time is mere minutes. Building software is cheap. Because there is nothing else for us pesky humans to do, almost all human effort is dedicated to the design of the software.


So software development, from a human perspective, is almost entirely a design process, with the end result being a technical design written in a language that the true software builders (i.e computers) can understand.