Natural Language Processing: From BERT to Production NLP Systems

Natural Language Processing in Production: Real Use Cases (2026)

Quick answer. Natural language processing enables computers to understand human language across a spectrum, from shallow structure extraction to deeper comprehension. In production, NLP systems extract value from unstructured text, detect customer intent, and automate manual review, but must handle ambiguous, context-dependent, edge-case-laden real-world text.

Natural language processing has moved from academic research into production systems at scale. At Viprasol, we've implemented NLP systems that extract value from unstructured text, understand customer intent, and automate work that previously required human review.

But production NLP is messier than research papers suggest. Real-world text is ambiguous, context-dependent, and full of edge cases. This guide covers practical approaches based on what we've learned deploying NLP systems that actually work in production.

What Natural Language Processing Actually Does

NLP is the field concerned with enabling computers to understand human language. But "understand" is a spectrum.

Shallow understanding extracts structure from text without deep comprehension. Recognizing that "apple" appears in a sentence, counting word frequency, extracting names and dates. This is surprisingly useful.

Semantic understanding grasps meaning. Recognizing that "The bank approved the loan" discusses finance and approval, not geography and river banks. Identifying that two sentences express similar ideas despite different wording.

Pragmatic understanding accounts for context and intent. Recognizing when someone asks "Can you fix the bug?" they want you to fix it, not comment on your ability. Understanding that "We need to circle back" means "let's schedule a follow-up", not that geometry is involved.

Each level requires different techniques and computational resources. Production systems rarely achieve pragmatic understanding across all inputs. Most successful systems combine shallow and semantic understanding, with humans handling edge cases.

Practical Production Use Cases

Customer Support and Ticket Routing

Incoming support emails, chat messages, and forms create ticket volume that overwhelms manual triage. NLP automates initial routing.

How it works:

• Customer submits a support request
• NLP classifier determines the issue category (billing, technical, account management, etc.)
• Request routes to appropriate team
• Sentiment analysis flags urgent issues (angry customers)
• Similar past tickets are retrieved for reference

Result: 40-60% of straightforward issues route correctly automatically. Complex or novel issues still reach humans.

What we've learned: don't aim for perfect categorization. 85% accuracy is often sufficient because humans review misclassified tickets. Focus instead on classifying tickets that don't benefit from human review (billing inquiries, password resets, FAQ questions).

Document Classification and Processing

Organizations receive many documents: applications, contracts, forms, invoices. Humans read and categorize them manually.

NLP systems can:

• Classify documents by type (loan application vs. mortgage refinance)
• Extract relevant information (applicant name, income, property value)
• Identify missing or incomplete information
• Flag documents that need manual review

This works well because document types are usually consistent and the information to extract is well-defined.

Named Entity Recognition and Information Extraction

Many business processes require extracting structured data from unstructured text. An insurance claim describes an incident; you need to extract date, location, people involved, damage description.

NLP systems can identify:

• Person names and roles
• Company names and relationships
• Locations and dates
• Amounts and currencies
• Products and services mentioned

At Viprasol, we've built systems that extract entities from job descriptions, research papers, customer feedback, and technical documentation. The accuracy depends on how structured the source text is. Technical documentation is easier than casual customer feedback.

Sentiment Analysis

Understanding whether customers are satisfied, frustrated, or neutral matters for customer experience, product development, and team morale.

Systems analyze:

• Support interactions (is the customer satisfied with their resolution?)
• Product reviews (do customers like the new feature?)
• Social media mentions (how are people talking about the company?)
• Employee feedback (what's the sentiment in internal communication?)

Challenges: sarcasm is hard. "Great, another email thread" is negative despite "great". Domain-specific terminology changes meaning. In customer service, "fast response" is positive. In personal communication, "fast response" might mean you're pushy.

Semantic Search and Similarity

Users describe what they want, and systems must find relevant documents or products.

Applications:

• Finding similar customer support tickets (before reopening, check if it's been solved before)
• Product recommendation (if someone searches "waterproof sports watch", recommend similar products)
• Content discovery (if someone reads an article about microservices, recommend related architecture articles)
• Knowledge base search (instead of keywords, understand intent)

Traditional keyword search fails when terminology differs. Someone searching "water-resistant sports watch" won't find results indexed as "waterproof sports watch" unless you use semantic similarity.

Automated Summarization

When processing many documents or support tickets, summaries save human time.

NLP systems can:

• Summarize lengthy documents (quarterly earnings calls → key points)
• Extract meeting minutes (recorded call → agenda items, decisions, action items)
• Identify key facts in support tickets (lengthy customer complaint → problem statement)

This works well for factual content. Summarizing opinion pieces or creative writing is harder because meaning comes from style and nuance.

Technical Approaches in Production

Transformer-Based Models

Models like BERT, GPT, and T5 have become the standard approach. They're pre-trained on massive amounts of text, so they understand language patterns. You fine-tune them for specific tasks.

Advantages:

• Strong performance on many tasks
• Reasonable accuracy out-of-the-box
• Transfer learning (pre-training helps with new tasks)

Challenges:

• Large models are computationally expensive
• Require GPU/TPU resources in production
• Can be slow for real-time applications
• Fine-tuning requires labeled data

We've used transformer models when accuracy is critical and we can afford latency (processing batch jobs). For real-time applications, we often use smaller, faster models.

Smaller, Optimized Models

Sometimes you can trade accuracy for speed and cost. Smaller models:

• Run on regular servers (no GPU needed)
• Respond in milliseconds instead of seconds
• Cost less to run at scale

Approaches:

• Knowledge distillation: Train a small model to mimic a large model's predictions
• Quantization: Reduce model precision (32-bit to 8-bit) to shrink size
• Model pruning: Remove low-importance weights

We use these when real-time response is critical and "good enough" accuracy suffices.

Rule-Based Systems

For specific, structured tasks, rules can outperform ML:

• Extract dates using regular expressions and date parsing
• Identify currency amounts using pattern matching
• Flag sensitive keywords (payment info, health data) for audit

Rules are:

• Fast and deterministic
• Easy to debug and maintain
• Transparent (no "black box" predictions)

Drawback: rules don't generalize well. A rule for extracting phone numbers is domain-specific.

Hybrid Approaches

Most production systems combine approaches:

• Rules handle straightforward cases
• ML handles ambiguous cases
• Humans review uncertain predictions

Example: extracting entities from invoices. Use rules for clearly formatted fields (invoice number, date). Use ML for fields with variable format (customer address, item descriptions). Flag low-confidence predictions for human review.

Building Production NLP Systems

Step 1: Define the Problem Clearly

Many organizations start with "we want to use AI" without defining what problem they're solving. Be specific:

• What input do you have? (customer emails, documents, feedback)
• What output do you need? (category, extracted information, sentiment)
• What does "good" look like? (what accuracy is acceptable?)
• What's the constraint? (latency, cost, scale)

If you can't articulate these, you're not ready to build a system.

Step 2: Start with Baseline

Before building ML, establish a baseline. How well does a simple approach work?

Simple approaches:

• Keyword matching (does the email contain "refund"? → category is billing)
• Regular expressions (find patterns that reliably identify what you want)
• Simple counts (what topics appear most frequently?)

A simple baseline often achieves 70-80% accuracy with zero ML overhead. Understand why the baseline fails before investing in ML.

Step 3: Collect and Prepare Data

ML requires examples. Collect representative data:

• Customer emails for a support classifier
• Customer reviews for sentiment analysis
• Invoices for information extraction

Prepare by labeling data. Someone manually categorizes emails, rates sentiment, or extracts information. This is tedious but essential.

Data quality matters more than quantity. 1,000 carefully labeled examples outperform 100,000 low-quality labels.

Step 4: Choose an Appropriate Model

Model selection depends on your constraints:

• High accuracy, high latency acceptable: Use large transformer models. Fine-tune if you have labeled data; use zero-shot if you don't.
• Real-time response required: Use small, optimized models or rules.
• Limited labeled data: Pre-trained models help; they transfer knowledge from massive unsupervised training.
• Specific domain: Fine-tune on domain data after pre-training.

Common misconception: bigger models are always better. Bigger models are better at tasks they're designed for, but smaller models are better for your specific scenario if latency or cost matters.

Step 5: Evaluate Rigorously

Don't trust accuracy percentages. Evaluate against your actual use case.

Key metrics:

• Precision: Of predictions we made, what percentage were correct? (High precision means few false alarms.)
• Recall: Of true cases, what percentage did we catch? (High recall means we rarely miss cases.)
• F1 score: Balance between precision and recall.
• Confusion matrix: See what kinds of mistakes the model makes.

Also evaluate cost and latency:

• How long does prediction take per request?
• What does it cost to run at your scale?
• How much would errors cost you?

A system that's 95% accurate but takes 10 seconds per request might be less valuable than a system that's 85% accurate and takes 100 milliseconds.

Step 6: Deploy Carefully

Even good systems fail in production. Deploy carefully:

• Start with a small percentage of traffic (5-10%)
• Monitor predictions, not just accuracy metrics
• Alert on unexpected input patterns (concept drift)
• Maintain human oversight (sample predictions, review errors)

A/B test against the existing approach. If your NLP system doesn't outperform humans or the existing system, investigate why before expanding.

Step 7: Monitor and Iterate

Production changes over time. Inputs shift, terminology evolves, context changes. Monitor your system:

• Track accuracy metrics continuously
• Alert when accuracy degrades
• Collect misclassified examples
• Periodically retrain with new data

We've seen systems perform excellently for months then start failing as the input distribution shifted. Without monitoring, these failures go unnoticed.

Data and Privacy Considerations

NLP systems often process sensitive data: customer communications, personal information, financial data.

Data minimization: Collect only data you need. If you need to classify support tickets, don't also extract and store customer phone numbers.

Retention limits: Keep labeled data and training data only as long as you need. Deletional systems follow "right to be forgotten" requirements.

Model transparency: Understand what information your model learned. Some models can be analyzed; large neural networks are opaque.

Bias awareness: Training data reflects real-world bias. If your training data comes from a specific group or region, your model might perform poorly for others. Test across diverse inputs.

When NOT to Use NLP

NLP isn't always the answer. Recognize when simpler approaches work:

• If you can solve the problem with rules or keyword matching, do that. It's simpler, faster, and easier to maintain.
• If you have small input volume, manual processing might be cheaper than building and maintaining an NLP system.
• If the problem requires human judgment or nuance, don't try to fully automate it.
• If you lack labeled data, building custom models is hard. Pre-trained models help but might not be accurate enough.

NLP makes sense when:

• Input volume is large enough that automation saves significant time or cost
• The problem is well-defined enough that consistent rules apply
• You have data to train or fine-tune models
• Reasonable accuracy is achievable

Internal Resources

For building NLP systems, consider:

• AI agent systems for intelligent document processing and automation
• SaaS development for embedding NLP into your product
• Web development services for customer-facing NLP applications

Reader Questions

Q: Can I use off-the-shelf APIs instead of building custom models?

Often, yes. Services like AWS Comprehend, Google Cloud Natural Language, and OpenAI APIs provide pre-built NLP capabilities. If their features match your needs, using APIs is cheaper and faster than building custom models. Use APIs for initial exploration, then build custom models if your requirements diverge.

Q: How much labeled data do I need?

It depends on the task and model. With transformer models and transfer learning, you can achieve reasonable accuracy with 500-1000 labeled examples. With simpler models, you might need 10,000+. Start with what you have, measure accuracy, and collect more data if needed.

Q: How do I handle languages other than English?

Many transformer models support multiple languages natively. Multilingual BERT supports 100+ languages. If you need language-specific accuracy, models fine-tuned on that language perform better. For rare languages, you might lack training data.

Q: Can I extract information from unstructured documents (PDFs, images)?

Yes, but it's harder. You first need to extract text from PDFs or OCR from images. Then apply NLP to extracted text. OCR errors propagate through your NLP system, reducing accuracy. For documents in structured formats, this works well. For handwritten documents or complex layouts, it's challenging.

Q: How do I update my model when new data arrives?

Continuous retraining approaches exist but are complex. Most production systems retrain on a schedule (weekly, monthly) using accumulated new data. This balances keeping the model current with operational complexity.

Q: What's the difference between NLP and machine learning?

NLP is a specific application of machine learning focused on language. Machine learning includes computer vision, recommendation systems, and other domains. Most NLP systems use machine learning techniques, but not all machine learning systems are NLP.