Natural Language Processing (NLP) Roadmap for 2026

Natural language processing has changed more in the last few years than almost any other part of machine learning. Large language models can now draft, summarise and answer questions, and it is tempting to start there. But the people who build reliable language systems still rely on older foundations: how text becomes numbers, what a strong baseline looks like, and how to evaluate language output honestly. This roadmap builds those foundations first and reaches modern models on solid ground.

It assumes you can write Python and train a basic model. If not, begin with the machine learning roadmap and return after its core supervised learning stage.

Stage 1: Text as data

Raw text is messy: encodings, punctuation, casing, typos, emoji, mixed languages. Learn:

• Unicode and encodings, so text in Telugu, Hindi or any non-Latin script survives your pipeline intact.
• Regular expressions for finding and cleaning patterns.
• Tokenisation, splitting text into units, from simple word splitting to the subword tokenisers used by modern models.
• Normalisation such as lowercasing, and when not to apply it: casing carries meaning in names and acronyms.

The free textbook Speech and Language Processing by Jurafsky and Martin covers these foundations and everything that follows, up to transformers and large language models (Jurafsky and Martin: Speech and Language Processing).

Project: clean and tokenise a real corpus, such as product reviews, and report its vocabulary size, most frequent terms and the share of non-English text.

Stage 2: Classical baselines, and why they matter

Before any neural network, learn the bag-of-words representation with tf-idf weighting, which counts words in each document and down-weights words common to all documents (scikit-learn: text feature extraction). Paired with a linear model, it is fast, interpretable and often hard to beat. Here it classifies newsgroup posts into four topics, twice:

import numpy as np
from sklearn.datasets import fetch_20newsgroups
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import f1_score
from sklearn.pipeline import make_pipeline

topics = ["comp.graphics", "rec.autos", "sci.med", "sci.space"]
def load(subset, strip):
    return fetch_20newsgroups(subset=subset, categories=topics,
                              remove=("headers", "footers", "quotes") if strip else ())

for strip in (False, True):
    train, test = load("train", strip), load("test", strip)
    model = make_pipeline(TfidfVectorizer(sublinear_tf=True, min_df=2, stop_words="english"),
                          LogisticRegression(max_iter=1000))
    model.fit(train.data, train.target)
    score = f1_score(test.target, model.predict(test.data), average="macro")
    print(f"{'without' if strip else 'with'} headers, footers and quotes: macro F1 {score:.3f}")

with headers, footers and quotes: macro F1 0.943
without headers, footers and quotes: macro F1 0.866

Two lessons in two lines. First, a model that trains in seconds scores 0.866 macro F1 on four roughly balanced topics, where guessing would get about one post in four right; any fancier model must beat this. Second, the higher score is inflated. With email headers, signatures and quoted replies left in, the model partly learns who posted and which thread a message belongs to, not what it is about. The scikit-learn documentation warns about exactly this and recommends stripping them for a realistic evaluation (scikit-learn: 20 newsgroups). Text data is full of such shortcuts: boilerplate, templates, usernames and dates that correlate with labels.

Linear models also show what they learned:

words = np.array(model[0].get_feature_names_out())
for i, topic in enumerate(train.target_names):
    print(f"{topic}: {words[np.argsort(model[-1].coef_[i])[-5:][::-1]].tolist()}")
print(len(train.data), "training posts,", len(test.data), "test posts,", len(words), "words in the vocabulary")

comp.graphics: ['graphics', 'file', 'image', 'files', '3d']
rec.autos: ['car', 'cars', 'engine', 'dealer', 'ford']
sci.med: ['doctor', 'msg', 'disease', 'medical', 'pain']
sci.space: ['space', 'orbit', 'nasa', 'moon', 'launch']
2365 training posts, 1575 test posts, 13250 words in the vocabulary

Most words are what you would expect. "msg" is a surprise until you read the posts: 42 of the 594 medical training posts discuss the food additive MSG. Reading a model's strongest features is how you find both real signal and quirks of your data.

Project: build a tf-idf baseline for a real classification task, report macro F1 and per-class scores, and write up the ten worst errors.

Stage 3: Embeddings and meaning

Bag-of-words treats "car" and "automobile" as unrelated. Embeddings represent words, sentences or documents as dense vectors placed so that similar meanings sit close together. Learn how word embeddings capture similarity, how sentence embeddings from pre-trained models support semantic search and clustering, and how cosine similarity is used to compare them.

Project: build a semantic search over a set of FAQs or support articles, and compare its results with keyword search on the same questions.

Stage 4: Transformers and fine-tuning

Transformers, built on the attention mechanism, underlie modern NLP. Learn the architecture at the level of its parts: tokenisation into subwords, embeddings, attention, and the difference between encoder models, which read text and suit classification and extraction, and decoder models, which generate text. How to read a machine learning research paper walks through the original Transformer paper and re-implements its attention step. Then learn to fine-tune a pre-trained encoder on your own labelled data. The Hugging Face LLM course teaches this with the Transformers, Datasets and Tokenizers libraries (Hugging Face: LLM course).

Project: fine-tune a pre-trained encoder on the same task as your stage 2 baseline, and report whether the gain justifies the extra cost in training time and inference speed.

Stage 5: Working with large language models

Much applied NLP now means building on large language models rather than training them. The skills that matter:

• Prompting with structure: clear instructions, examples, and output formats a program can parse.
• Retrieval-augmented generation: fetching relevant documents with embeddings and giving them to the model, so answers are grounded in your data.
• Evaluation: building a test set of questions with expected answers, checking factual accuracy and faithfulness to sources, and measuring cost and latency. Generated text is much harder to evaluate than a class label, which is why this skill is valued.
• Risks: fabricated answers, leakage of private data in prompts, and bias in outputs. Design for them from the start.

Project: a question-answering assistant over a document collection, with an evaluation set of at least 50 questions and a written report of where it fails.

Stage 6: Specialise and ship

Choose a direction: information extraction such as named entities, search and ranking, conversational systems, summarisation, speech, or multilingual NLP for Indian languages, where good labelled data is scarcer and careful data work matters even more. Learn to serve models within latency and cost limits, and to monitor them on live text, which drifts as language, products and users change.

A checklist for every NLP project

Tokenisation, tf-idf, word embeddings and sentiment analysis make up the natural language processing module of the Data Science course, which is followed by an introduction to generative AI covering transformers, LLMs and prompt engineering.

Sources

• Speech and Language Processing (3rd edition draft) — Stanford University
• Text feature extraction (scikit-learn) — scikit-learn documentation
• The 20 newsgroups text dataset (scikit-learn) — scikit-learn documentation
• LLM Course (Hugging Face) — Hugging Face