Some products just seem irrationally expensive:

- A design for a small website can cost thousands of dollars.
- Smartphones become increasingly more expensive, even though there aren’t as much new, exciting features included as in the past.
- You can buy headphones at a price of 10$ but also spend several thousand dollars for a pair of headphones.

The obvious question is: How are these prices justified? A good answer is crucial, especially for designers. There are drag-and-drop website builders out there that cost nearly nothing. Hence, why would anybody pay a designer lots of money to do something similiar?

Sadly, a pretty common answer:

“I have to make a living, as well.”

This response is bad, because a) you could have chosen a better-paid job and b) there’s a great answer: Maths.

Hopefully, fter reading this article, you’ll be able to prove why quality is expensive and how to justify your price.

### Some Basic Definitions

To show something mathematically, we have to provide some premises or definitions that are the fundament of our argumentation.

At first, we’ll have to define the term “quality” in a mathematical way. Often, the easiest strategy is to use the limits of a function or set. In this case, we’ll say:

- A product of highest quality fulfills all demands. This is equal to saying: It has no errors.
- A product of lowest quality fulfills none of the demands. This is equal to saying: It has all possible errors.

Now, we have defined the quality Q of a product that is somewhere between 0 and N, where N is the number of demands. We can say:

Q = the number of fulfilled demands.

This is true, if we assume that every demand requires an equal effort to be fulfilled, which is good enough for an approximation.

We see that it’s necessary to have a complete product specification to measure quality. If you can’t measure a goal, you can’t reach it.

We’ll also have to accept a second assumption: The higher the quality, the higher the price. Note, that we don’t say the price increases linearily with quality, we just say: A product of higher quality will cost more than a product of lower quality.

### More Definitions and some Conclusions

Furthermore, we can say: It’s infinitely simple to create a product of lowest quality: No action/work is needed to create such an outcome. Hence, it doesn’t cost anything. We define: The price P of a product of no quality is 0:

P(0) = 0

Now, we can think about how the price of a product increases with an increasing number of fulfilled demands.

Let’s say, we have to fulfill one demand. For this situation, we can say for P:

P(1) = 1

If we have two demands, things get a bit more complicated. We can’t just say *P(2) = 2*, because if we fulfill the first demand, this interferes with the second demand. We have to say:

P(2) = 2 fulfilled demands + 1 interference

If we assume that every demand interferes with every other demand, we pretty much have a fully connected graph. Every vertex is a demand and every edge an interference. Luckily, there is a formula for the number of edges in a fully connected graph:

Edges = N*(N-1)/2, where N is the number of vertexes/fulfilled demands

Hence, we can define for P(Q):

P(Q) = P(N)

And

P(N) = k*(N+N*(N-1)/2), where k is a constant that defines the real price

If we look at this term, we notice that we have a quadratic relationship between quality and price. If we want to achieve a 100% increase in quality, our price doesn’t double but quadruple. Of course, this model isn’t perfect, but it’s a good approximation to show you how hard it is to improve a great product.

### Big Ns

Sadly, this nice formula doesn’t work with very large Ns, because humans are a) imperfect and b) finite. Some projects require thousands of man-years, hence they can’t be built by one single person. A consequence of several persons working on a project is a decreased efficiency-per-person as there is an increasing demand for communication and administration. Also, humans make mistakes and the longer they work on a project the bigger the risk of tunnel-vision becomes.

Another problem is: The more number of fulfilled demands (and interferences) you have, the less unfulfilled demands are left to meet. Obviously, the easiest problems are addressed first, hence, development becomes increasingly more difficult in the end.

Example source code: It’s very easy to write perfect code if we talk about a very limited number of demands or only a few lines of code. If we talk about several million lines of code, it’s pretty much impossible to write perfect code and to fix it, because every fix could impact other parts of the code.

On the other hand, for very small Ns, the demand-interference isn’t this relevant because humans are built to fulfill such tasks as a consequence of evolution.

Hence, we can define for large Ns:

Quality can be between 0 and 1, but not 0 or 1.

Q = ]0;1[

It’s infinitely simple to produce a product that fulfills no demands. Hence, we can conclude:

lim(P(Q)) = 0, for Q → 0

*where Q = number of fulfilled demands/number of demands*

This essentially allows us to stop talking about absolute Ns and instead say: If we want to meet 20% of our demands, we’ll have this price.

We can also define: It’s infinitely hard to produce a product that fulfills all demands. Hence, we can conclude:

lim(P(Q)) = ∞, for Q → 1

*where Q = number of fullfilled demands/number of demands*

If we draw this asymptotes and assume a differentiable function, we get this: