Cloud Architecture / DevOps / PaaS / Presales / Technology



This post presents a cost modelling approach by which to compare private versus public platform-as-a-service (PaaS) Cloud delivery platforms. An R based script is supplied which can be downloaded and customised to generate a cost-comparison graph.


Service delivery platforms built according to Cloud architecture principles are becoming the dominant platform pattern. Compound percentage annual growth rates for PaaS adoption are in the high 20s. The properties that comes to mind when considering something in terms of a Cloud architecture include elasticity, automation and secure, dense, multi-tenancy. The focus shifts to managing workloads not the virtualisation of operating system instances. Platform as a Service (PaaS) is one example of a workload hosting platform based on a Cloud architecture.

PaaS Choices

PaaS comes in two basic flavours – private or public. In this post, public PaaS refers to an Internet accessible service provided by a third party secured by some form of commercial arrangement and associated service level agreement (SLA). An example here includes the Amazon offering known as Beanstalk. Private PaaS describes a PaaS offering made available as a supported product which can be deployed as the client sees fit, e.g. on premise, off premise, in a virtual private cloud or even to the public cloud.

Evaluation Criteria

Given this distinction, the question turns to relevant evaluation criteria. The public PaaS variant trades off potentially lower initial on-boarding and start-up costs with the usual risks associated with a single sourcing strategy, e.g. proprietary lock-in, dependency on an external party for feature enhancements and commercial contractual constraints. Publicly hosted PaaSes also raise data sovereignty and response-time issues as the location of the Data Centre is outside our control.

In the private model, the client has control over the placement, deployment and customisation of its PaaS cloud based delivery model. Startup costs for a private deployment are possibly higher than the public model because the client must negotiate the standing up of the initial PaaS infrastructure. However, data sovereignty and response-times are within the clients control. Additionally, assuming the private PaaS conforms with open standards, single-supplier risks such as proprietary lock-in can be eliminated or neutralised.

Cost Comparison

We focus now on cost as an evaluation criteria, as other factors can be subjective or highly context specific to the client circumstances. For this we need some form of cost model while of course reminding ourselves that models are just that – imperfect representations that simplify the real world.

Public PaaS Model

One cost input modelling approach to the Public PaaS model can be summarised using two basic parameters:

  • Yearly per application hosting costs in non-production environments
  • yearly per application hosting costs in production environments

These costs tend to be set by the public PaaS provider and are typically uniform, meaning your costs scale up linearly as you grow your PaaS workload fleet. Different costing apply to production versus non-production as typically different service level agreements are required.

Private PaaS Model

The cost inputs to the private PaaS model differ as in this case we scale up by provisioning more infrastructure to host additional applications. We will use the term node to denote an infrastructure element used to host applications. This typically takes the form of an operating system instances realised through e.g. virtualisation technology, on bare metal, via Openstack, Amazon, Rackspace etc. The multi-tenancy of the PaaS Cloud architecture means that each additional node can host many new applications. Cost elements to consider then are:

  • Yearly cost of each non-production node
  • Yearly cost of each production node
  • Density of application hosted per non-production node
  • Density of application hosted per production node


The hypothesis is that compared to the public PaaS cost curve, there exists some break-even point at which the higher set-up costs of the private PaaS are mitigated by scale efficiencies of dense multi-tenancy (operational scale economies). Another way of stating this is that while the multi-tenancy optimisations inherent to true PaaS Cloud architectures reduce costs, only in a private deployment can one guarantee that such savings transfer back to the owner/operator.

The model is visualised as per the graph below using artificial inputs into the costing parameters.


The costing model and graph can be customised to represent your scenario. The code base is for the R statistical package and is provided below. The cost inputs can be customised as necessary to reflect your site specific circumstances. To rebuild the graph download R, adjust the costing inputs and re-run the script.

Create yourself an account on and run this script.

# Name: paasonomics.R
# Author: Stefano Picozzi
# Blog:
# Date: November 2013

# Financial model to compare yearly operational application hosting costs between a conventional versus PaaS model.
# In this model conventional is also referred to as PMO, PaaS as FMO
# representing present and future mode of operation respectively.
# Instructions:
# To run, download and install R and recommended helpful related tools such as RStudio.
# Change the working directory in this code to reflect your environment.
# Manipulate assumptions by editing variable settings as indicated inline.



# Helper function for pretty money display
printMoney <- function(x) {
  gsub(" ", "", paste("$", format(x, digits = 10, nsmall = 0, decimal.mark = ".", big.mark = ","), sep = ""))

# Set up some plotting related constants
maxCost <- 2000000
maxApp = 15
cost <- printMoney(seq(0, maxCost, 50000))
ppi <- 300
app <- seq(1, maxApp, by = 1)

# Blended average per year costs for a virtualised or bare instance of O/S
instanceCost <- 10000

# FMO = future mode of operation == PaaS
# PMO = present mode of operation == Convential deployments

# Once off costs to establish FMO environment in Year One
fmoProdEstablishCost <- 100000
fmoTestEstablishCost <- 50000

# Once off costs to establish Present Mode assumed as Zero
pmoProdEstablishCost <- 0
pmoTestEstablishCost <- 0

# Node == application host instances
# Mgmt == supporting management infrastructure

# Blended average incremental software costs for PMO instance
pmoProdNodeCost <- instanceCost + 2000
pmoTestNodeCost <- instanceCost + 2000
pmoProdMgmtCost <- 0
pmoTestMgmtCost <- 0

# Blended average incremental software costs for FMO instance
fmoProdNodeCost <- instanceCost + 8000
fmoTestNodeCost <- instanceCost + 5000
fmoProdMgmtCost <- instanceCost + 1000
fmoTestMgmtCost <- instanceCost + 600

# Instances required for PaaS environment
fmoProdMgmtNo <- 6
fmoTestMgmtNo <- 4
# Nodes scale up as we host more applications based on this model:
fmoProdNodeNo <- 4 + (as.integer(app/6)*2)
fmoTestNodeNo <- 4 + (as.integer(app/10)*2)

# Net additional FMO Administration costs
fmoAdmFTE <- 0.2
fmoAdmFTECost <- 100000
fmoProdAdmCost <- 0 + (as.integer(app/6)*2)*(fmoAdmFTE * fmoAdmFTECost)
fmoTestAdmCost <- 0 + (as.integer(app/10)*2)*(fmoAdmFTE * fmoAdmFTECost)

# Instances required for PMO environment per application
pmoProdNodeNo <- 4
pmoTestNodeNo <- 3
pmoProMgmtNo <- 0
pmoTestMgmtNo <- 0

# PMO total cost model
pmoProdTotalCost <- pmoProdEstablishCost + (pmoProdNodeNo * app * pmoProdNodeCost)
pmoTestTotalCost <- pmoTestEstablishCost + (pmoTestNodeNo * app * pmoTestNodeCost)

# FMO total cost model
fmoProdTotalCost <- fmoProdEstablishCost + + fmoProdAdmCost + (fmoProdMgmtNo * fmoProdMgmtCost)  + (fmoProdNodeNo * fmoProdNodeCost)
fmoTestTotalCost <- fmoTestEstablishCost + fmoTestAdmCost + (fmoTestMgmtNo * fmoTestMgmtCost)  + (fmoTestNodeNo * fmoTestNodeCost)

# PMO per application unit costs per year
pmoProdAppCost <- pmoProdTotalCost/app
pmoTestAppCost <- pmoTestTotalCost/app

# FMO per application unit costs per year
fmoProdAppCost <- fmoProdTotalCost/app
fmoTestAppCost <- fmoTestTotalCost/app

# Comment this out to run in
#png(paste("~/paasonomics.png", sep = ""),
# 	res = ppi,
#   width = ppi*8,
#   height = ppi*8,
#   units = "px")	

# Set up plotting data frame for ggplot
# Note that for FMO using loess smoothed curves
# but can convert back to stepped function if preferred
df <- data.frame(app)
df$pmoTotalCost <- pmoProdTotalCost + pmoTestTotalCost
df$pmoAppCost <- pmoProdAppCost + pmoTestAppCost
loProd <- loess(fmoProdTotalCost ~ app)
loTest <- loess(fmoTestTotalCost ~ app)
df$fmoTotalCost <- predict(loProd) + predict(loTest)
loProd <- loess(fmoProdAppCost ~ app)
loTest <- loess(fmoTestAppCost ~ app)
df$fmoAppCost <- predict(loProd) + predict(loTest)

# Melt it so ggplot can easily plot and create legend
df.long <- melt(df, id.vars = "app")

# Some R ggplot magic to draw the graph
ggp <- ggplot(df.long, aes(x = app, y = value, colour = variable)) +
  geom_line(size = 2) +
  ggtitle("PMO v FMO\nConventional versus PaaS Deployment Model Costs") +
  ylab("Year1 Costs (includes FMO establishment)") +
  xlab("No. of Apps") +
  scale_y_continuous(breaks = seq(0, maxCost, 50000), labels = cost) +
  scale_x_discrete(breaks = seq(1, maxApp, 1), labels = app) +
  labs(colour = "Legend") +
  scale_colour_manual(labels = c("PMO Total Cost", "PMO per App Cost", "FMO Total Cost", "FMO per App Cost"), 
    values = c("red3", "orangered", "seagreen", "darkolivegreen4")) +
    legend.position = c(0.0, 0.77),
    legend.justification = c(0,0)) 



Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s