Coursify

Steps in Natural Language Processing (NLP): A Practical Pipeline

Steps in Natural Language Processing (NLP): A Practical Pipeline

Verified Sources
Nov 4, 2026

Natural Language Processing (NLP) typically follows an end-to-end pipeline: convert raw text into a structured representation, learn patterns, then produce task outputs. A common high-level sequence includes Text preprocessing, Tokenization, Linguistic annotation, Feature representation, Modeling, and Evaluation.

Below is a concise, widely used set of steps—shown at the right level to cover both “classic” NLP workflows and modern transformer-based systems.

Key idea: Different tasks (sentiment, NER, translation, QA) reuse most of these steps but vary in the details of annotation, representation, decoding, and metrics.2

Footnotes

  1. Stanford CS224N (Natural Language Processing with Deep Learning) - Course Notes/Topics: tokenization, parsing/NER, and overall NLP process. https://web.stanford.edu/class/cs224n/ ↩

  2. Jurafsky & Martin / NLP overview concepts (preprocessing, modeling, evaluation; TF-IDF/embeddings and metrics). https://web.stanford.edu/~jurafsky/slp3/ ↩

NLP Pipeline Overview (preprocessing → features → models)

Core steps in an NLP workflow

  1. 1
    Step 1

    Specify the NLP goal (e.g., classification, NER, translation, summarization), the input type (text vs. speech), and the output format (label set vs. generated text).

  2. 2
    Step 2

    Clean/normalize text: remove noise, standardize casing, handle punctuation, normalize unicode, and optionally filter stop words. Also manage document structure (sentences, paragraphs).

  3. 3
    Step 3

    Split text into tokens (words or subwords) and map them consistently to the model vocabulary; many modern systems use subword tokenization.

  4. 4
    Step 4

    Add intermediate structure such as part-of-speech (POS) tags, dependency parses (Dependency parsing), and named entities (Named entity recognition).

  5. 5
    Step 5

    Convert tokens/structures into numeric vectors (e.g., TF-IDF for classic ML, or embeddings such as transformer hidden states).

  6. 6
    Step 6

    Train a model to map representations to outputs; then run inference to produce predictions (class scores, entity spans, or generated sequences).

  7. 7
    Step 7

    Transform raw model outputs into the final format (e.g., choose labels, extract spans, convert token IDs back to text, apply constraints).

  8. 8
    Step 8

    Measure performance with task-specific metrics (e.g., accuracy/F1 for classification/NER, BLEU/ROUGE for generation). Iterate on preprocessing, representation, labeling, and model design based on error analysis.

Brief explanation of each step

  1. Task definition: Determines the pipeline branches (what annotations you need, what decoding you use, which metrics matter).
  2. Preprocessing: Reduces variability and noise so downstream steps and models focus on meaning-bearing signals.
  3. Tokenization: Provides the atomic units a model can process consistently; modern NLP often tokenizes into subword units to handle rare words and morphology.
  4. Linguistic annotation (optional, but common): Adds interpretable structure (POS tags, dependencies, named entities) that can improve performance or enable structured prediction.2
  5. Feature representation: Converts text (and annotations) into numeric inputs. Classic approaches use sparse features (e.g., bag-of-words, TF-IDF), while modern systems use contextual embeddings.
  6. Modeling: Learns patterns from labeled data (or performs inference in pre-trained models).
  7. Decoding/post-processing: Converts model outputs into task-appropriate predictions or text, often handling formatting and constraints.
  8. Evaluation & iteration: Uses metrics that align with the task objective and guides improvements.

Common “task switch”: If your output is a label, you typically emphasize classification training and metrics like accuracy/F1. If your output is generated text, decoding quality and generation metrics become central.

Footnotes

  1. Stanford CS224N (Natural Language Processing with Deep Learning) - Course Notes/Topics: tokenization, parsing/NER, and overall NLP process. https://web.stanford.edu/class/cs224n/ ↩ ↩2 ↩3 ↩4

  2. Jurafsky & Martin / NLP overview concepts (preprocessing, modeling, evaluation; TF-IDF/embeddings and metrics). https://web.stanford.edu/~jurafsky/slp3/ ↩ ↩2 ↩3 ↩4 ↩5

  3. spaCy documentation (pipeline components like tagging/NER as structured steps). https://spacy.io/usage/processing-pipelines ↩

Practical mental model

Think of NLP as: normalize → represent → predict → evaluate. Annotation and linguistic parsing are “representation upgrades,” not mandatory steps for every modern approach.

Be careful mixing evaluation regimes

Generation tasks use metrics like BLEU/ROUGE, while extraction/classification tasks often use F1/accuracy. Using the wrong metric can lead to misleading conclusions about quality.

Footnotes

  1. Jurafsky & Martin / NLP overview concepts (preprocessing, modeling, evaluation; TF-IDF/embeddings and metrics). https://web.stanford.edu/~jurafsky/slp3/ ↩

Typical NLP development lifecycle

Define task & data requirements

1) Problem setup

Collect examples and define target output and evaluation metric."

Preprocess + represent

2) Pipeline design

Decide tokenization, normalization, and feature/embedding strategy."

Train/infer

3) Learning

Fit a model and run inference for predictions."

Evaluate + iterate

4) Quality assurance

Compute metrics, inspect errors, refine preprocessing/labels/model."

Where each step matters most (by common NLP task types)

Relative emphasis—higher means that step is more critical for that task style.

Common variations you’ll encounter

NLP pipeline quick checks

1 / 5
Question · Term

What does preprocessing do in NLP?

Click to reveal
Answer · Definition

Cleans and normalizes raw text (e.g., casing, punctuation, unicode), reducing irrelevant variability for modeling.

Knowledge Check

Question 1 of 4
Q1Single choice

Which sequence best describes a typical end-to-end NLP pipeline?

Explore Related Topics

1

LR Parsing Classification: Top-Down, Bottom-Up, Recursive, and Predictive

2

Instruction Pipelining: Meaning, Rationale, Working Procedure, and Performance Measures

Browse all research articles