Reliance Jio Customer Churn Radar and next best action

Summary

Reliance Jio built a reusable, factory-pattern churn prevention platform on Databricks for 535 million customers, designed to be replicated across all Reliance verticals with minimal tweaking.
The platform links churn signals to next-best actions and integrates with campaign systems, cutting campaign cycles from weeks to real-time delivery through a human-approval step that validates actions before they reach customers.
This video explains Reliance's decision to use Databricks and the key principles behind building scalable, enterprise-grade solutions at the cost constraints of India's broadband market, including Jio's roughly 30 million home broadband users.

Reliance Jio Customer Churn Radar and next best action

Reliance Jio’s home business (JioFiber + JioAirFiber) operates at a very large scale and is a leader in India’s home broadband market, with both fiber-to-the-home (FTTH) and 5G fixed‑wireless (FWA) connectivity users totalling ~30 million.
In India’s broadband market, Jio accounts for roughly half of total broadband subscribers, with over 500 million wireless broadband (mobile included), giving it the largest overall broadband share.
Talk By: Raghuram Velega, Vice President- Group Head Data Platform, Reliance Industries ;

Chapters

FAQs

How does Reliance Jio use Databricks for churn prevention at scale?

Reliance Jio built a churn prevention platform on the Databricks Data and AI platform for 535 million customers that links churn signals to next-best actions and feeds them into campaign systems in real time. The platform was designed as a reusable template so the same solution can be applied across all Reliance businesses with very little modification.

What is the factory pattern approach Reliance Jio uses for data solutions?

The factory pattern means Reliance builds a solution once on Databricks and replicates it across all its verticals with minimal changes, rather than building separate solutions for each business unit. This approach is essential for propagating technology across the scale of the entire Reliance ecosystem efficiently.

How does Reliance Jio validate next-best actions before sending them to customers?

The platform includes a human approval step in the loop before actions are sent to customers, ensuring business users can review and validate AI-generated recommendations. This governance layer keeps the system accountable while still enabling real-time campaign execution.

How does Databricks Genie fit into Reliance Jio's churn platform?

Databricks Genie serves as a natural-language business interface for churn predictions, allowing non-technical business users to query the platform's outputs without writing SQL or code. This enables business and data teams to collaborate directly on churn insights and next-best-action decisions.

Full transcript

[00:11] How was the conference? How was the keynote? It's good. Yeah, a lot of cool things coming up, right? Very interesting. Yeah. So, uh let me start off uh
[00:24] by asking you guys, do you know Reliance by any chance? Okay, a lot of people know. Very good. Very good. Yeah. So, >>
[00:37] the largest telco in the world. We also are one of the largest retailer in India. Uh we have the
[00:49] largest refinery in the world. So, we are a big energy producers in India.
[01:01] And all of these uh we run everything at scale. And for us, scale and cost are two important factors because in India is a very cost-sensitive market, right? So,
[01:13] so we we were thinking, you know, how do we how do we really bring value to our customers? And how do we build something which could be like a factory pattern
[01:27] which we build once and we replicate. So, that was one of the key principles what we go with. Because if we have to enable any technology across the Reliance ecosystem, you need to build like a factory, or
[01:40] else it's very difficult to propagate. Uh so, we made a decision to go with Databricks, uh you know, a year back. And it actually has transformed uh the way we started looking at data
[01:53] and we started building solutions around it. So, what I want to really focus on today is for an enterprise how value can be engaged using
[02:05] Databricks and what that value is and how do we look at it from implementing that at the scale of Reliance and the scale of Indian pop- population. Okay. So, that's the
[02:18] key thing. So, >>
[02:32] Uh we said see, we have a scale of around 535 million customers for which we want to basically build a platform which can prevent churn.
[02:44] Looks very simple. But in fact, that was not all. We said the platform should not just be a use case for you. You need to build actually a template so that if I can
[02:58] enable it for solving the churn problem for one of my verticals with Jio, I should be able to use this across all my businesses with very
[03:10] little tweaking. That was uh condition number one. Condition number two. Typically, when someone goes and builds a use case they first go, look at the data, they do
[03:22] some feature engineering, they think what the model is, then they basically go and and you know, do some kind of AB testing on it and then eventually deliver. We said that's the old way. We do that all the time. We don't want to do it.
[03:34] You think and let's do it in a very completely new way. And that's the new way which I want to talk to you about. What we what they helped us build and what we were able to achieve is we put AI to do
[03:48] the work for us and humans to do the review and approving of it. And that actually showed the value and I'll tell you the kind of value what it brought in. Not only the value of building that use case end-to-end,
[04:00] reducing the time from couple of months to a few days. That was the value we saw. We also could unearth a lot of features which were not possible when you try to
[04:12] build an end-to-end AI use case. We use Genie code extensively in this whole ecosystem. We build a lot of templates which were notebooks, which were all configurable,
[04:24] so that you don't really have to recode things when you go to new use cases. And we proved this capability by taking it and using in other use cases and we're able to reduce
[04:37] our our development span from months to days, right? So, that's that's the second thing. Third, the other problem we said is we don't build things to build. We want to build
[04:49] things where there is a value. So, if you want to build where things are value, you need to first quantify the value. So, for us, we had a clear direction that if today my churn is around 2%, we need to cut it to half,
[05:02] 1%, right? That was the value we want to generate. So, whatever we did in this, we tried to prove to that value, how do we reach to it? And we'll show you how we built it.
[05:15] So, the whole purpose of this talk was to say how it helped us to keep the value in view, use the AI to build everything end-to-end, and how to create everything in a
[05:28] machine readable format with guardrails and security, right? So, that was the other one. Uh third was we wanted to be everything closed looped. So, that's a fundamental principle which
[05:40] we go with. Whatever action we take to generate a value, we need to have a closed loop which can actually go back to each of your steps and start rectifying it.
[05:52] So, that's basically what it is. So, I'll give you a a quick view of you know, the loop which was built to to help us tackle the churn problem
[06:05] because at the scale what we are with 524 million customers with 20 million home customers. Home is pretty much your broadband which you have to So, we got 50 million home customers
[06:17] today. Almost 70% of the network traffic of India goes through our networks. And to basically predict churn, prevent churn, take actions on churn,
[06:31] and validate whether these actions are appropriate or not was not possible without putting AI first in the loop. Right? So, that's that's what this is.
[06:46] Uh what we realized in case of churn, right? It was more It was not about the plans which people were. It was all about experience. And the experience was very front-loaded, which is what we
[06:59] realized. It's usually in the first 6 months you get all the signals required to tell you that the customer is going to be churning or not. Again, how did we realize this?
[07:11] We actually put in agents in front of our data. And then we told the agents to go and find out the signals what they thought they could do. Right? So, very different from the way we typically build an AI/ML pipeline.
[07:24] Right? Because we usually do by tribal knowledge. Oh, we know we say, "Oh, it's because the recharge is not doing in 30 days. He could be churning. His consumption is dropping, so he could be churning." But we did not do that. We said, "This is the data which is
[07:37] available in your data bricks. We have the Unity catalog where all the metadata there. We have tagged every element of the metadata there, and we told our agent, which was built using cloud code, to go
[07:49] and find out the reasons. First, find out where is the pain pain point across. So, now we have very clearly articulated that it is about an experience to it is about the first 6 months, where we had
[08:03] to be very careful. There also, if you look at it, the first 30 days, which we call the baby care, was the most important one. If we can take care of a customer in the first 30 days, and then the first 6 months, then he's there for
[08:15] life. Again, with AI, this was possible very quickly. We could have done that in a traditional way, no doubt about that. Now, the other problem what we had was
[08:28] we had all the possible signals. The signals could be, you know, billing anomalies. The signals could be repeat complaints. Uh the signals could be, you know, network alarms coming in, right? We have all those signals. But, what we
[08:40] really lacked is how do we link these signals to actions what we want to create, right? Now, typically what you do in a traditional EIML pipeline is, you know, you have got 10 different actions. Your
[08:52] SMEs have thought about it. They said, "Oh, if I give a certain, you know, um you know, do do a campaign for him with some kind of an offer, he would stay back." Right? They would either send it
[09:04] through any channel they wish. It could be an SMS going to him, a WhatsApp going to him, an email going to him, right? That's how we used to do it earlier. We said, "Let's not do it that way. Let's do it differently today." So, what we said is why don't we put
[09:19] agents and AI in front of it, and let it decide what is the reason why a person is planning to churn. And that we did not That again, we we
[09:31] basically gave the full data sets to it. We made it generate all the features from it. And on the features, we basically apply the right models so that the right sharp values can come out of it, right? And
[09:44] this was all run using AI in front, and all this was built using um Genie code. The whole loop. Once we build this, it was converted into templates. So,
[09:57] each of the steps had a very clear template with a configuration so that we could repeat these steps across uh different use cases. Right? Now,
[10:12] the actions in this case was not just saying that, you know, whether a customer is going to churn. It was also about when is the potential that he'll be churning. Also, what is the best channel to communicate to him where the potential
[10:25] of him clicking on that is maximum. So, all that was sort of taken from this, right? And these actions within triggering automatically our execution
[10:38] pipeline. Typically, in a traditional organization, what happens is you have actions, and then you hand it over to your campaign team, and then they do their bit, they create the creatives, they upload the creatives, they figure
[10:51] out what to be sent, and they send it out, right? We integrated all those things together into one box. So, it's not only predicting churn for the customers who are going to be churning, it's also choosing the right
[11:04] channels through which we have to be doing the actions around them. It's executing those actions, capturing the outputs, and feeding it back. If we see that for a certain set of
[11:17] customers who are potential to churn are not recharging, and for us, recharge is a very important aspect. That's how customers come back. We then go back and look at it. It's whether we have done a wrong campaign,
[11:29] or we have done a wrong channel campaign, or our our our models were not right, right? So, that whole feedback loop again comes back from from the outputs into each of this, and all this whole
[11:41] thing runs as a uh you know, a continuous pipe. Right? That's what we built. Because that was very important to clue close loop the whole thing. Uh
[11:53] now, of course, we did not leave it everything to the machine, and I think no one should. We actually put a human at every step of it. All the way from the point of feature
[12:05] engineering to model selection, to AB testing, to campaign or action choosing the right actions and campaigns to be sent, we had humans in the loop.
[12:17] Humans were empowered with the data which was generated. So, what we did was we built apps, we built Data Bricks apps, we embedded them at every step of the flow, so that we could see what's happening in each of the areas, and we could make a
[12:30] human either approve or reject that uh that step before it goes to the next step, right? The reason why we did that is because see, once we start training it, after some time, it'll be more automatic,
[12:42] right? So, it was a machine doing most of the work, and the human trying to uh validate what's happening and and augment uh what's happening. Uh also, what we did So, typically, we what
[12:56] we used to do is whenever you have to do a campaign, right? It used to be pretty much a pre-curated uh creative, and we send the same creative to everyone. What this enabled us to do is we could
[13:08] AI was generating the narratives at a customer level. So, if a customer was having a problem with billing, we could see that, you know, there was a campaign sent to him talking specifically about his billing problems and saying how we can help him. If a customer was
[13:21] disgruntled because he had bad service and he had service down for a few days, we would give him an offer of a credit saying that, you know, next month you can have a credit. So, it was very targeted is what this could help us do because now we are using agents and
[13:34] humans were not in the loop. We also closed loop this by integrating into IVR so that, you know, the IVRs could basically do the call outs to customers and customers could uh you know, could get the
[13:47] personalized call outs to people to use them. Right? So, again, this would not have been possible without the agent sitting in the ecosystem and humans monitoring it. Right. So, how did we do that?
[14:00] So, we followed a a four-layer nested approach. At the center, which we call the nucleus, was Databricks. All the capabilities of Databricks were at the center.
[14:13] On top of that, we have a four-layer operational loop and I'll go through that in detail. On top of that, we had the agentic layer, which was doing the reasoning and creating the next best action required and the next channel to be chosen.
[14:26] And at the topmost layer was the business blueprint. So, if you see the difference here, right? The blueprint was a very critical piece for us. Whenever you try to do a use case,
[14:38] right? If you do not understand what the business wants and whatever the business wants, if you do not convert it into some kind of a machine-readable format, there is no way you can achieve the outcome the business wants. We would build something, but business
[14:51] would say, "This is no use for me." Right? So, we followed a a four-layered approach. I'll go through each layer, how we did that. So, we'll start with the business layer. So, before even we wrote a single line
[15:05] of code, we went worked very closely with the business. They were part of the same pod. And we looked at every aspect what they did. We looked at all their SOPs what they do today. We converted that to a
[15:17] machine-readable format. We looked at the SMEs' understanding of what they do today. We told them to, you know, codify that into a simple you know, text plain text, right? Then we went and looked at
[15:29] all the tech interfaces what's what they were doing today. We documented all those things. We went and looked at all the policies and decisions what they did today. We again documented all that stuff. We went and looked at all the guardrails which we want to do today,
[15:41] right? We put all those things into a textual format. And we took all this information and we converted into a machine readable format and put it in Databricks. So, this is like building the context on
[15:54] what is my end goal where I want to reach if I have to build something together, right? That this was the first step what we followed. Right. So, this was basically converting all the business knowledge what we want to use
[16:06] into a machine readable format and feed it in so that that aids you in doing your next steps. Second, the architecture. So, we created an architecture in four layers.
[16:19] One was data itself where we made sure that the data was the right quality. It had all the quality rules embedded in them. We also made sure that
[16:32] the features which were created of the data were the ones which would help us achieve the goal which we had set as part of layer one. Second is prediction.
[16:45] Once we have our features created we basically predicted the reasons why a churn would happen, what the drivers for the churn are, churner, what the explainabilities for the churner, especially the sharp values and
[16:57] everything. And then next was actions to be taken based on what the predictions were done and eventually executing it. Now, the difference what you see here it's not just the forward loop but is the backward pass.
[17:09] Every step of it we had a loop which went back and refreshed it. For example, let's say my outcome wasn't right. It would go back into each of these layers and start checking whether do I
[17:22] have to refresh my features because I'm not able to get the kind of, you know, outcome I'm looking for, right? Whether I have to retrain my model because maybe it's not right. Whether I have to do the right routing, right? Because to maybe I'm routing
[17:35] for a customer who's who doesn't even use WhatsApp. I'm sending a WhatsApp message. A better one would be an IVR call to him, right? Or we go back and look at, you know, campaign optimization. So, each layer is where we
[17:49] try to do the the loop back and see how we can rectify that. Again, this is again a template if you look at it. We use it for churn, but we we sort of template ties this for other use cases, too.
[18:03] Okay. Now, how do we now template ties the agents to do the following? So, we defined a five-layer methodology for every agent. So, every
[18:15] agent has an input. Every agent does an action. Every agent has an output. Every agent can have unknowns. And every agent needs a guardian. So, all agents what we have built, we
[18:28] actually use this methodology so that it's well defined because agents typically do not uh give an exception, but they just give you a wrong answer. That's how they are built.
[18:40] So, so we basically made a template out of saying that, "Okay, let's put a the mechanism around that and use this mechanism to to build these agents." So, that's the agentic framework what we put together.
[18:54] Now, coming down to the nucleus, so the capabilities we have used uh most of the Databricks capabilities. We have used the Genie code extensively while building this.
[19:07] Uh of course, we have to adapt for the deployment part of it. We have used the Unity catalog for this. We have put the UVs lake lake base for that for our agents to do quick inferencing. Uh
[19:19] and and we use we use AI genies as an as an output of of what's being generated, right? So that we can see what's happening in our in our churn flow. And so this
[19:31] was the core. This also we try to template ties it so that, you know, for similar things, what are the different tools required? And and and they can be used for for generating your your end-to-end flows.
[19:44] Right? Now, what did we do? So in order to do this, we created nine specialized regions. One was the churn predictor. One was the Again, agents when we look at it, we typically went with small
[19:58] tasks, not large, right? So there's a clear input, output, and guardrail so that they don't get confused. If you give a lot of things to agents, they start hallucinating. So we have a churn predictor, we have a sharp value
[20:10] creator, we have a churn explanator, and then we have got action agents. Then we had got, you know, execution agents, which is either you know, sending a message to the call center or
[20:23] sending out a campaign or doing some analysis on it like like a genie so that you can get outputs of that, right? So So again, we followed the same pattern, those five-step pattern to build an
[20:36] agent. We built these following agents to create the output. And we fed all the data in a machine-readable format, and we made sure the data was very clean, and and it did not have any, you know,
[20:48] anomalies in them. Now, where does a human sit in this whole loop? So for every agent what we created, we had an
[21:00] human in the loop. We built these humans in the loop using Data Bricks apps, and we we sure that, you know, he has got the right inputs which show for him so that he can make a decision of a no go go or no go to the
[21:12] next stage. So, that's how we have created it and we and each of these actions was again logged so that, you know, those logs can be reviewed and and they can be audited at any part of time.
[21:25] So, the accountability was still with the with the human. The policies were the guardrails which came from our topmost layer, layer one, right? And of course uncertainties uncertainties were
[21:37] accounted for so that they can be fixed in a continuous manner. so this whole thing was one loop for us, right? All the way from detecting,
[21:50] predicting, stratifying what the problem is, explaining it, deciding our next best action, approving it, executing and learning, right? So, this is the whole loop. So, one template, eight layers,
[22:03] and every customer at risk would be captured in this eight layers. And if you do not, we would learn and we'll come back and and execute this.
[22:17] So, out of this, what did we what did we learn? So, we learned a lot of things. Uh we did Initially, when we started off, of course, we did not put AI in the front. We were doing it in a traditional way. Uh but eventually learned that, you
[22:30] know, we know we need to do it in a different way and that's where we put AI in the front. And once we had built this, we saw that this is something can be repurposed for other use cases. If you have the data and if you have the
[22:43] data with no anomalies in them, you could really use these templates and these methodologies with machine readable
[22:56] uh inputs and the methodologies of the agents and the four layers, we could expand it to multiple use cases. So, Jio Home was the first one
[23:08] which we did, and now we are working towards enabling it for multiple use cases and different products using the same methodology. Right?
[23:25] Uh this is just you know, how how churn has helped us uh you know, uh give a good experience to our customers. Uh it also has helped us protect our revenue. So, these are key These were the key drivers. So, these drivers which
[23:38] we talk about here were actually codified in our layer one, right? So, now what happens with this is if an agent has got an input which is data well defined, you have an output which was the layer
[23:50] one, the business outcome which you're looking for well defined, then with the right tooling, you can actually build things faster, better, and some things which you don't know also comes out of it, right? So, that was the learning what we
[24:02] got, and uh we were able to build this. Any So, basically AI runs the loop and human owns the judgment is what we do. Yeah, please go. >> Thank you very much.

Learn more about the Databricks Data and AI platform.

The information provided herein is for general informational purposes only and may not reflect the most current product capabilities or configurations.