Netcore Personalization: Revealing the 15-Minute Integration Secret
Written by

Subscribe for updates

Netcore Personalization: Revealing the 15-Minute Integration Secret

Published : May 18, 2020
  1. Our AI engine, Raman, can predict with high accuracy what product or content each customer is likely to buy or consume next
  2. Powered with this knowledge, it is then able to show the most relevant and personalized products or content across every digital touch-point – on the website, mobile app, or across emails, push notifications, in search, and social media ads
  3. And, all of this is made possible through a super-quick integration on behalf of the clients

Sounds exciting and interesting? 

How do we make this magic happen through hassle-free and speedy integration, though?

AI Walk Down Memory Lane!

Circa 2018: We were able to deliver consistent revenue and conversion uplifts by 8-13% for our clients using our patented AI-led personalization algorithms.

We spent years building and fortifying our AI engine, Raman, but there was one challenge that remained constant.

Integration was a tedious and time-consuming experience! 

Why was integration so painful? There are two parts to this problem:

  1. Our AI engine is data-hungry: Raman needs to ingest customer behavioral data (clicks, views, add-to-carts, favorites, purchases, searches, filters, etc.), product catalog data, and customer data to constantly learn in real-time and predict the most relevant and personalized recommendations for each user
  2. Displaying these recommendations takes effort: Once Raman is able to accurately predict the products a customer is most likely to buy or consume; these 1:1 recommendations have to be shown via widgets, category page reordering etc. This requires substantial integration effort on the client’s part.

We know what you might be thinking.

Why wouldn’t any company put in the time and effort to integrate with a product that consistently produces a conversion rate uplift of 8-13%?”

We dug deeper to hit upon a very relatable analogy. Think back to the salespeople at major supermarkets or grocery establishments who nudge you to sample a new type of multi-grain bread or salsa dip? Only if the sample wows you will you think of investing money and effort in purchasing it!

What does this mean in product terms?

Our clients want to put our promised increase in conversion rates on their website or mobile app to test – before making a substantial effort in integration. Add to this mix a busy and overcrowded product pipeline which may need to be revised to accommodate this new product into their tech stack.

But, hang on – isn’t this an industry-wide issue? What can we do about this?

This was an oft-repeated statement during our tech huddles. We could have thrown in the towel, accepted ground reality, and the fact that “the industry worked like this”. 

A lot of tech introspection later, one of our developers asked out loud, “What if we build a method of integration where the client wouldn’t have to do anything at all?” 

There was stunned silence. Initially, it sounded like a far-fetched idea. But, it was clear that this challenge required a radical solution, sooner than later.

We went back to the drawing board. Within 3 months, we had built the prototype for the “Minimal Effort Client Integration” module. We tested it with a couple of clients before productising it completely.

Fast forward to 6 months later, we have a fully working integration module where the client spends only 15 minutes to integrate the Smartech JS snippet on their website…and we take over from there!

Decoding the Magic!

Here’s how we make this possible for clients with Smartech doing all the heavy-lifting:

  1. Capture Customer Data, Accurately

Once the client places the JS snippet on their header, our integration team configures triggers to get whatever data-points we need to begin personalizing recommendations at scale. 

We start collecting clickstream data, customer information, product catalog, geolocation, device-type, browser type and version, time spent across pages and during every session, etc.

Step 1: Capturing Customer Data, Accurately

Let us dive deeper:

  1. Whenever a visitor comes to the website, the Smartech JS SDK is served via a Cloudfront CDN
  1. The JS then identifies whether the customer is new or repeating, evaluates rules, and attaches listeners to the DOM
  1. The onboarding team sets up all the triggers and rules at our end via a UX friendly interface. This gives them the flexibility to cater to different kinds of websites and set triggers customized to each client
  1. Clickstream data, device, browser, OS, geolocation data, etc. is then pushed to the Amazon Kinesis stream via APIs on AWS Lambda
  1. Depending on the priority of data (recommendations need real-time data while reporting doesn’t), data from the Kinesis stream is de-queued via consumer APIs on AWS Fargate-ECS 

Capturing user data dynamically lays the foundation to generate and highlight the most relevant recommendations, tailor-made to individual customers.

  1. Render Relevant Recommendations through Widgets

Our JS also has the functionality to inject HTML sections back to the client’s website. Our widgets configuration panel allows us to replicate the client’s UI theme and functionality back to our widgets.

Even on the Product Listing Page (Category Page), we can inject Rows 1,3,5 with personalized dynamic recommendations. Our JS can also inject a new page on a new menu item which did not exist before and we power it with our Personalized Boutique Page (a curated list of products dynamic to each user). 

The shoppers on the website won’t know the difference and we’ll continue to own a large part of the website real estate allowing us to show the most relevant recommendations to each customer.

Step 2: Rendering Relevant Recommendations through Widgets

Let’s dive deeper:

  1. When a visitor lands on a page, the JS SDK sends a recommendation request to Smartech’s personalization engine along with the current context data (which page the user is on, device, browser, time/date fields, OS, geolocation, etc)
  1. Recommendation requests are processed by the API server which fetches recommendations from the model server (Tensorflow), both autoscaled on Kubernetes
  1. These recommendations form the context for rendering the widget templates in Lambda
  1. The rendered widgets are injected in a pre-determined location on the client’s website ensuring a seamless user experience.
  1. Establish a Monitoring and Alerting Stack

This integration is further backed by a robust monitoring and alerting system which signals us if anything is about to go wrong. The relevant alert is sent to the concerned team at the desired frequency via multiple channels. We act on it and resolve it before it has any impact on the client’s business.

Step 3: Establish a Monitoring and Alerting Stack

Let’s dive deeper: 

  1. One of the data streams (mainly logs, few metrics) feeds into our Monitoring and Alerting system
  1. It is a highly effective stack where data is pushed into elasticsearch via logstash
  1. Kibana on top of elasticsearch is used for analysis, visualization, and dashboarding
  1. All alerting rules are configured in a UI-friendly interface (a kind of query-builder which can be used by non-technical users as well)
  1. Alerts are sent to different stakeholders depending on the type of alert at pre-configured frequencies. Alerts can be mailed, triggered over Flock, or be passed on to Jira; creating a ticket

Cutting-Edge Technology + Client-Centric Mindset = Data-Driven Promise!

So, that’s how we’ve made the entire integration process with Smartech hassle-free, seamless, and reliable. And, that’s also a glimpse into how we keep you – our clients – and your end customers at the hub of our value proposition wheel.

To get your AI-led personalization growth story kickstarted, get in touch, today. Improving CTRs by 30-60% and conversions by 8-13% across your website or mobile app has never been easier!

Unlock unmatched customer experiences,
get started now
Let us show you what's possible with Netcore.