How to Leverage NLP for Product Data Science

You are a data scientist on a product team, and your stakeholders ask: which customers are about to leave, and why? You have login data, billing history, and feature usage. But you also have signals hidden in support tickets, reviews, and survey responses, offering a lot of context that none of those tables capture.

This is a common situation for product data scientists, whose models are built almost entirely on behavioral data. Meanwhile, natural language processing (NLP) has become one of the strongest capabilities within data science, but is often discussed separately from this kind of work. Yet the two fit together more naturally than they might seem.

This article walks through common product problem areas and how a small set of NLP techniques can strengthen each one. I have also provided boiler-plate code and links to resources to get started.

···

···

Product Data Science

Several types of data science roles have emerged, each with similarities and differences. Some focus on natural language processing and LLMs, while others may be geared toward data engineering and pipeline development.

One type of role is the product data scientist. A product data scientist focuses on analyzing user behavior, optimizing product features, and growing the business through modeling, experimentation, and metric design. They work on problem areas such as customer churn or CLV modeling. While these probems are not trendy or “cutting edge,” they are not going away for businesses, and they take a particular skillset to answer. These roles also place a stronger emphasis on stakeholder engagement and being part of the business, since these problem areas touch every part of the organization (sales, marketing, etc.) instead of sitting within an isolated technical team.

While the product data scientist may seem distinct from those who specialize in NLP, the two skillsets can greatly complement each other. Below is a list of common product areas and how certain NLP techniques can strengthen traditional models.

···

Common NLP Themes

Before diving into product use cases, you will see common themes throughout them that boil down to three families of techniques:

• Classification: the task of assigning text to a predefined category or label, such as sentiment (positive/negative), a risk rating (high risk, low risk), etc.

• Topic & Cluster Analysis: the task of grouping text by meaning (without predefined categories), surfacing higher-level insights like themes, rather than assigning labels decided in advance.

• Embedding-Based Retrieval/Similarity: the task of representing text as dense vectors, enabling the measurement of similarity that powers capabilities like semantic search and recommendation systems.

A few techniques in the use cases below fit these families indirectly. Named entity recognition (NER) is classification applied to individual words and phrases rather than whole documents, and embedding-based anomaly detection builds on the same vectors as similarity search.

···

NLP Use Cases

Customer Churn Prediction

Understanding the driving factors behind customer churn and identifying those at risk can help organizations plan marketing campaigns, adjust pricing, and allocate resources properly. Churn models are traditionally built on behavioral and transactional data, containing features like login frequency, product usage, payments, etc. However, sentiment from customer support conversations, reviews, and surveys often shifts before the behavior does, giving these models earlier signals that can supplement usage and transactional data. Topics extracted from customer support tickets can also be used as categorical features, turning the model from “who’s leaving” into “who’s leaving and why.”

These techniques can be used in additional propensity models to predict the likelihood of other events like a user converting, upgrading membership, etc.

NLP Techniques: Sentiment Classification (fine-tuned BERT/RoBERTa), Topic Modeling (BERTopic), Text Classification

Sentiment Classification Example

from transformers import pipeline#load pre-trained sentiment modelclassifier = pipeline("sentiment-analysis", model="cardiffnlp/twitter-roberta-base-sentiment-latest")#sample support/review texttexts = ["Onboarding was confusing and support took days to respond.",         "This update made everything so much easier to use."]#run classificationresults = classifier(texts)print(results)

Customer Lifetime Value (CLV)

Modeling a customer’s lifetime value can help organizations forecast earnings and allocate their spending and resources. CLV models rely on purchase data, typically using probabilistic models or gradient-boosted regression on behavioral features. These models can struggle with newer customers, where there isn’t enough data to work with yet. Where NLP can help is tracking sentiment trends across customer support history or the topics they discuss in product reviews, giving the model a signal before their purchase history builds up.

NLP Techniques: Sentiment Classification (fine-tuned BERT/RoBERTa), Topic Modeling (BERTopic), Text Classification

Topic Modeling Example

from bertopic import BERTopicfrom sentence_transformers import SentenceTransformer#initialize embedding model and generate embeddingsembedding_model = SentenceTransformer("all-MiniLM-L6-v2")embeddings = embedding_model.encode(documents, show_progress_bar=True)#fit BERTopic modeltopic_model = BERTopic(embedding_model=embedding_model, verbose=True)topics, probs = topic_model.fit_transform(documents, embeddings)#view top topicstopic_model.get_topic_info().head()

Customer Segmentation

Customer segmentation is critical for organizations to deliver personalized marketing, optimize spending, and more. Segmentation typically clusters customers on recency, frequency, monetary value, and other behavioral features. But NLP-derived segments can surface new clusters that would not be seen in behavioral data. By clustering customers with their language in reviews, support tickets, or survey responses, you can create groups like “price-sensitive but vocal about quality” or “quiet high-value users.” These text-based segments are usually combined with behavioral clusters, rather than replacing them.

NLP Techniques: Text Clustering (K-means/HDBSCAN), Topic Modeling (BERTopic)

Text Clustering Example

from sentence_transformers import SentenceTransformerfrom sklearn.cluster import KMeansfrom hdbscan import HDBSCAN#embed textembedding_model = SentenceTransformer("all-MiniLM-L6-v2")embeddings = embedding_model.encode(documents)#k-means (requires a defined number of clusters)kmeans = KMeans(n_clusters=5, random_state=42, n_init="auto").fit(embeddings)kmeans_labels = kmeans.labels_#hdbscan (no k required, isolates outliers automatically)hdbscan_model = HDBSCAN(min_cluster_size=10, metric="euclidean").fit(embeddings)hdbscan_labels = hdbscan_model.labels_

Recommendation Systems

While product data scientists may not be responsible for building recommendation systems, it is still a focus area as these systems can influence vital metrics like click rates or watch time, and can be the basis for experimentation. A common problem of recommendation systems is that they have nothing to work with for new users or items with no data yet. Embedding item descriptions and other content lets the system recommend on content after just a few clicks, closing the gap until behavioral data accumulates. Most recommenders today are hybrids for this reason, blending behavioral data with text-based embeddings rather than relying on one approach.

NLP Techniques: Embeddings (Sentence-BERT/Item2Vec), Cosine Similarity, Vector Search (FAISS/ANN)

Cosine Similarity and Vector Search Examples

from sklearn.metrics.pairwise import cosine_similarity#compare a query embedding against a set of item embeddingssimilarities = cosine_similarity([query_embedding], item_embeddings)#index of the most similar itembest_match_index = similarities.argmax()

import faissimport numpy as np#build a FAISS index from item embeddingsdimension = item_embeddings.shape[1]index = faiss.IndexFlatL2(dimension)index.add(item_embeddings)#search for the nearest neighbors of a query embeddingk = 5distances, indices = index.search(np.array([query_embedding]), k)

Pricing & Elasticity

It is vital that organizations understand the price elasticity of their products to optimize pricing and maximize revenue. Elasticity models leverage price points, conversion rates, and competitor pricing, so it is easy to assume text has no role here. However, sentiment and topic analysis on reviews and customer support tickets that mention price can be converted directly into a price-sensitivity feature, letting you segment customers by elasticity instead of treating the entire customer base as equally price-sensitive.

NLP Techniques: Sentiment Classification, Text Classification, Topic Modeling (BERTopic)

Text Classification Example

from sklearn.feature_extraction.text import TfidfVectorizerfrom sklearn.linear_model import LogisticRegressionfrom sklearn.model_selection import train_test_split#sample labeled data (review/ticket text -> mentions price or not)#illustrative only, a real model needs hundreds of labeled examplestexts = ["Way too expensive for what you get", "Great value for the price",         "The subscription cost keeps going up", "Not worth the monthly fee",         "Love the new dashboard layout", "App keeps crashing on login",         "Support answered quickly", "Can't find the export button"]labels = ["price", "price", "price", "price", "other", "other", "other", "other"]#split, vectorize, and fitX_train, X_test, y_train, y_test = train_test_split(texts, labels, test_size=0.25, random_state=42, stratify=labels)vectorizer = TfidfVectorizer(stop_words="english")X_train_vec = vectorizer.fit_transform(X_train)clf = LogisticRegression()clf.fit(X_train_vec, y_train)#flag price mentions, which can be aggregated per customer as a price-sensitivity featureprice_flag = clf.predict(vectorizer.transform(texts)) == "price"

Demand Forecasting

Accurate demand forecasting lets organizations align production, inventory, and financial planning with future needs. Forecasting is largely a time-series problem that is built on historical data. But historical data misses potential signals, like a product going viral, brand controversy, a competitor stumbling, etc. News sentiment, social chatter, and spikes in review volume can be engineered as leading indicators, catching demand shifts before the historical trend would.

NLP Techniques: Sentiment Classification, Topic Modeling (BERTopic)

Anomaly Detection

Anomaly detection models serve many purposes in organizations, from detecting fraud to catching data quality concerns before causing issues downstream. Fraud models are traditionally built on transaction patterns and behavioral signals. But in some cases, embeddings can be leveraged on certain data, such as a fake review, a scam listing, and a phishing message that reveal themselves through language patterns rather than anomalous behavior.

NLP Techniques: Embeddings-based Anomaly Detection (Isolation Forest/Autoencoder)

Anomaly Detection Example

from sentence_transformers import SentenceTransformerfrom sklearn.ensemble import IsolationForest#embed text data (e.g., reviews or listings)embedding_model = SentenceTransformer("all-MiniLM-L6-v2")embeddings = embedding_model.encode(documents)#fit isolation forest on the embeddingsiso_forest = IsolationForest(contamination=0.05, random_state=42)iso_forest.fit(embeddings)#-1 = anomaly, 1 = normalpredictions = iso_forest.predict(embeddings)

Lead Scoring

Lead scoring, common at B2B companies, is a method for sales teams to rank prospects, ensuring they focus on the highest-potential buyers. This typically runs on firmographic and engagement data like company size, job title, email opens, and page visits. But what about what a lead actually says, like objections raised on a call, competitors mentioned or urgency expressed in an email? Extracting this signal turns a lead score from “how engaged are they” into “how ready are they, and what’s stopping them.”

NLP Techniques: Text Classification, NER (spaCy), Topic Modeling (BERTopic)

NER Example

import spacy#load pre-trained NER modelnlp = spacy.load("en_core_web_sm")#process text (e.g., a sales call transcript)doc = nlp("I spoke with a rep about switching from Salesforce next quarter.")#extract named entitiesfor ent in doc.ents:    print(ent.text, ent.label_)

···

Putting It Together

The examples above stop at the output: a sentiment label, a topic, a cluster. In practice, that output becomes a feature in the model you already have. The goal isn’t to build a separate NLP model, but to turn text into features that your existing model can use. Using churn as an example, we can score each support ticket, aggregate the results to the customer level, and join them onto the behavioral feature table.

Below is a flow diagram showing how our features come together, along with example code.

import pandas as pdfrom transformers import pipelinefrom sklearn.ensemble import GradientBoostingClassifierfrom sklearn.model_selection import train_test_splitfrom sklearn.metrics import roc_auc_score#score each support ticketclassifier = pipeline("sentiment-analysis", model="cardiffnlp/twitter-roberta-base-sentiment-latest")results = classifier(tickets["text"].tolist(), truncation=True)tickets["is_negative"] = [r["label"] == "negative" for r in results]#aggregate to one row per customer and join onto the behavioral featurestext_features = tickets.groupby("customer_id")["is_negative"].mean().rename("pct_negative_tickets").reset_index()df = churn_df.merge(text_features, on="customer_id", how="left").fillna({"pct_negative_tickets": 0})

Once the feature is integrated, the next question is whether it actually helps. The simplest test is to train the same model with and without the text feature and compare performance on a holdout set. Here we use AUC, but any metric your team already tracks works. If performance improves, the text is adding a signal that behavior alone misses.

behavioral = ["logins_30d", "feature_usage", "days_since_last_payment"]train, test = train_test_split(df, test_size=0.2, random_state=42, stratify=df["churned"])#compare the same model with and without the text featurefor name, cols in {"behavioral only": behavioral,                   "behavioral + text": behavioral + ["pct_negative_tickets"]}.items():    model = GradientBoostingClassifier(random_state=42).fit(train[cols], train["churned"])    print(name, roc_auc_score(test["churned"], model.predict_proba(test[cols])[:, 1]))

···

Takeaways

Looking back across these problem areas, patterns quickly emerge. NLP rarely works as a standalone model, but instead acts as a way to strengthen traditional models.

Text as an Earlier Signal Than Behavior

In churn, CLV, and demand forecasting, the same idea repeats: sentiment shifts in text tend to move before the numbers do. A customer’s tone in a support ticket changes before their usage drops, and review sentiment shifts before sales decline. It is all about bringing in earlier signals, which matters enormously for any prediction model.

Filling Gaps Where Behavioral Data Is Thin

CLV and recommendation systems depend on accumulated history, so they may struggle with new customers. A new customer has no purchase pattern for probabilistic models to work with, and a new item has no interaction data for collaborative filtering. In both cases, embedding text like descriptions, reviews, or early support conversations gives the model something to reason from before behavioral data exists.

Explaining the “Why,” Not Just the “What”

Behavioral and transactional data is good at telling you that something happened, but it can be difficult to determine why. Text is where the “why” can live, and pulling it out is what turns a lead score from “how engaged are they” into “what’s actually blocking them.” This is less about prediction accuracy and more about providing something actionable.

···

Helpful Links

Here are a few links to helpful documentation to get started:

···

NLP is a valuable addition to the product data scientist’s toolkit. Rather than replacing the traditional models behind churn, CLV, or demand forecasting, techniques like sentiment classification, topic modeling, and embeddings give them earlier signals from text that behavioral data alone could miss. With a small set of techniques, the right data, and a few lines of code, you can start strengthening capabilities throughout these problem areas immediately.

···

I hope you have enjoyed my article! Please feel free to comment, ask questions, or request other topics.

Connect with me on LinkedIn: https://www.linkedin.com/in/alexdavis2020/