Today, if you are building and operating cloud-based or cloud-native applications, the concentration of the source for TCO comes from one place.
Your development team.
That’s right, the developers essentially control your TCO and neither the business or the developers probably even know it. How is this possible? It is due to the fact that the efficiency of the code they write and publish has an outsized effect on the cost of operating your cloud-based application. This is especially true with so called server-less and managed technologies.
Let’s say for example a development team writes an AWS Lambda function that takes 10 seconds to execute. Now let’s say that if that algorithm were optimized, the run-time per event call could be reduced to 2 seconds, or even 5 seconds. You are paying for the time it takes the function to run, so reducing it by half, at scale, can result in major savings. Here’s another example, let’s say that the code in question makes a synchronous call to something (like a database query) and then sits and waits for the response. Now you’re paying for idle time, that is, you are paying for nothing. This is a significant factor for the cost of your operation.
How significant? It could be the difference between profitable and not. Consider that Internet companies operating at scale often have hundreds of such services running, each running potentially millions of times per day (if not more).
So how does a cloud-native business get a handle on this and make sure that TCO is actively and effectively managed? Here’s a basic check-list:
- Costs are part of the solution. Make sure the development team knows and understands the cost model for the technology operations. Many developers will write code to optimize the solution to the problem they are handed, not the efficiency of the cost model for running the code. This is a new skill that needs to be brought to product development teams and will create changes that ripple all the way back to design decisions.
- TCO is a responsibility, not an outcome. Make the cost of running the application part of the responsibility of the product team. In devops, the idea is that the development team is responsible to operate what they build and deploy. Take this a step further and give them the responsibility for cost. If the revenue model requires a certain level of cost efficiency, make sure the product team knows what this is. If your company uses incentive plans, include this metric.
- Optimize around architectural choices. Make sure the development team understands the cost models for various cloud service options. It may be that using a managed service is cheaper than running up an implementation in a virtual machine, or vice versa.
- Context is everything. Make sure the development team has the context of the business case being addressed by the code. For example, if the need is to trigger a report that the user will come back and get later, this can be designed differently than a synchronous set of processes, resulting in a more cost efficient implementation.