Although a basic CBM system will offer some solid benefits and insights, getting the most value from a CBM system requires more advanced components. Below we discuss some of the most important components, such as having churn models with multiple time horizons, adding price optimization, using simulation-based forecasting, and adding competitor pricing data.
Multiple horizon rotation models
Sometimes it makes sense to look at attrition from different perspectives, and one of those angles is the time horizon (or results period) that you allow the model to have. For some business scenarios, it makes sense to have a model with a short results period, while for others it may make sense to have a model with a 1 year results period.
To better explain this concept, let's say you create a churn model with a 10-week results period. This model can then be used to predict whether a given customer will abandon your business within a 10-week period. However, let's now assume that you have isolated a specific event that you know causes churn and that you have a short period of perhaps 3 weeks to implement any preventative measures. In this case, it makes sense to train a churn model with a 3-week horizon, conditional on the specific event known to cause churn. This way, you can focus any retention activities on customers most at risk of churn.
This type of differentiated approach allows for a more strategic allocation of resources, focusing on high-impact interventions where they are needed most. By tailoring the model's time horizon to specific situations, companies can optimize their retention efforts and ultimately improve customer lifetime value and reduce unnecessary attrition.
Price optimization and customer price elasticity
In many cases, price is the final part of strategy execution, and the winners are those who can effectively translate a strategy into an effective pricing regime. This is exactly what a reward-optimized CBM system allows companies to do. While the topic of price optimization easily deserves its own article, we've tried to briefly summarize the key ideas below.
The first thing you need to get started is to obtain historical price data. Preferably different price levels over time and other explanatory variables. This allows you to develop an estimate of price elasticity. Once this is in place, you can develop expected churn values at various price points and use them to forecast expected revenue values. Aggregation from the customer level provides the expected value and expected churn by product and can find optimal prices by product. In more complex cases, you can also have multiple cohorts per product, each of which has its optimal price.
For example, suppose a company has two different products, product A and product B. For product A, the company wants to grow its user base and is only willing to accept a certain amount of churn, while being competitive in the market. However, for product B they are willing to accept a certain amount of churn in exchange for having an optimal price with respect to expected revenue. A CBM system enables the implementation of such a strategy and provides leadership with a forecast of the strategy's expected future revenue.
Simulation-based forecasting
Simulation-based forecasting provides a more robust way to generate forecast estimates rather than simply making point estimates based on expected values. By using methods such as Monte Carlo simulation, we can generate probability densities for the results and thus provide decision makers with ranges for our predictions. This is more powerful than simple point estimates because we can quantify the uncertainty.
To understand how simulation-based forecasting can be used, we can illustrate with an example. Suppose we have 10 customers with certain churn probabilities and that each of these customers has an expected annual income. (Actually, we typically have a multivariate churn function that predicts churn for each of the customers.) For simplicity, let's assume that if the customer abandons we end up with 0 revenue and if they don't, we keep all the revenue. We can use Python to concrete this example:
import random
# Set the seed for reproducibility
random.seed(42)# Generate the lists again with the required changes
churn_rates = (round(random.uniform(0.4, 0.8), 2) for _ in range(10))
yearly_revenue = (random.randint(1000, 4000) for _ in range(10))
churn_rates, yearly_revenue
This gives us the following values for churn_rates and yearly_revenue:
churn_rates: (0.66, 0.41, 0.51, 0.49, 0.69, 0.67, 0.76, 0.43, 0.57, 0.41)
yearly_revenue: (1895, 1952, 3069, 3465, 1108, 3298, 1814, 3932, 3661, 3872)
Using the numbers above, and assuming that the churn events are independent, we can easily calculate the average churn rate and also the expected total revenue.
# Calculate the total expected revenue using (1 - churn_rate) * yearly_revenue for each customer
adjusted_revenue = ((1 - churn_rate) * revenue for churn_rate, revenue in zip(churn_rates, yearly_revenue))
total_adjusted_revenue = sum(adjusted_revenue)# Recalculate the expected average churn rate based on the original data
average_churn_rate = sum(churn_rates) / len(churn_rates)
average_churn_rate, total_adjusted_revenue
With the following numbers for average_churn_rate and total_adjusted_revenue:
average_churn_rate:0.56,
total_adjusted_revenue: 13034.07
Therefore, we can expect to have around 56% attrition and a total income of 13034, but this tells us nothing about the variation we can expect to see. To gain a deeper understanding of the range of possible outcomes we can expect, we turn to Monte Carlo simulation. Instead of taking the expected value of the churn rate and total revenue, we let the situation repeat 10,000 times (here 10,000 is chosen arbitrarily; the number should be chosen such that the desired granularity of the resulting distribution is achieved ), and for each instance of the simulation, customers churn with probability churn_rate or they remain with probability 1- churn_rate.
import pandas as pdsimulations = pd.DataFrame({
'churn_rate': churn_rates * 10000,
'yearly_revenue': yearly_revenue * 10000
})
# Add a column with random numbers between 0 and 1
simulations('random_number') = (
(random.uniform(0, 1) for _ in range(len(simulations))))
# Add a column 'not_churned' and set it to 1, then update it to 0 based on the random number
simulations('not_churned') = (
simulations('random_number') >= simulations('churn_rate')).astype(int)
# Add an 'iteration' column starting from 1 to 10000
simulations('iteration') = (simulations.index // 10) + 1
This gives a table like the following:
We can summarize our results using the following code:
# Group by 'iteration' and calculate the required values
summary = simulations.groupby('iteration').agg(
total_revenue=('yearly_revenue',
lambda x: sum(x * simulations.loc(x.index, 'not_churned'))),
total_churners=('not_churned', lambda x: 10 - sum(x))
).reset_index()
And finally, plot this with plotly yields:
The charts above tell a much richer story than the two-point estimates of 0.56 and 13034 we started with. We now understand much more about the possible outcomes we can expect to see and can have an informed discussion about what levels of attrition and income we consider acceptable.
Continuing with the previous example, we could say, for example, that we would only be willing to accept a 0.1% probability of 8 or more churn events occurring. Using individual customer price elasticities and simulation-based forecasts, we could adjust the expected forecast. churn_rates for clients so that we could achieve exactly this result. This type of customer base control can only be achieved with an advanced CBM system.
The importance of competitive prices
One of the most important factors in pricing is the competition's price. The aggressiveness of competitors will largely determine how flexible a company can be in its own pricing. This is especially true for commoditized companies, such as utilities or telecommunications, where it is difficult for suppliers to differentiate themselves. However, despite the importance of competitor pricing, many companies choose not to integrate this data into their own price optimization algorithms.
The reasons for not including competitor prices in pricing algorithms are varied. Some companies claim that it is too difficult and time-consuming to collect the data, and even if they started now, they still wouldn't have all the history they need to train all the price elasticity models. Others say the prices of competitors' products are not directly comparable to their own and would be difficult to compile. Finally, most companies also claim that they have price managers who manually monitor the market and when competitors make moves, they can adjust their own prices in response, so they don't need to have this data in their algorithms.
The first argument can increasingly be mitigated with good web scraping and other intelligence gathering methods. If that were not enough, there are also sometimes agencies that can provide historical market data on prices for various industries and sectors. Regarding the second argument about the lack of comparable products, machine learning techniques can also be used to determine the true cost of individual product components. Another method is also to use different users that can be used to estimate the total monthly costs of a specific set of products or products.
Ultimately, not including competitors' prices leaves pricing algorithms and optimization engines at a disadvantage. In industries where pricing calculators and comparison websites make it increasingly easier for customers to understand the market, companies risk being outpriced by more advanced competitors.
