Analysis Overview

Single-cell RNA-seq generates millions of reads from thousands of individual cells. Turning that raw data into biological insight requires a multi-step computational workflow. This page walks through each step and lists the main tools you will encounter.

The standard workflow

Every scRNA-seq analysis follows the same general pipeline. The details vary by tool, but the steps are consistent.

1. Raw data processing

The first step converts raw sequencing reads into a count matrix. Each row is a gene. Each column is a cell. Each value is the number of UMIs detected for that gene in that cell.

Tools:

• Cell Ranger (10x Genomics): the default for 10x Chromium data. Performs alignment, barcode demultiplexing, and UMI counting in one command.
• STARsolo: open-source alternative built into the STAR aligner. Produces the same count matrix format as Cell Ranger, often faster.
• Salmon Alevin: lightweight alignment using pseudomapping. Faster than full alignment, good for large datasets.
• Kallisto Bustools: another pseudomapping approach. Very fast, designed for single-cell quantification.

The output is typically a sparse matrix in Market Exchange format or an HDF5 file. This is your starting point for all downstream analysis.

2. Quality control

Not every barcode in the count matrix represents a healthy cell. You need to filter out three types of artifacts.

Empty droplets contain only ambient RNA. They have very low total counts. Tools like emptyDrops from the DropletUtils R package use a statistical test to distinguish real cells from background.

Dead or damaged cells release mitochondrial RNA when their membranes break. A high percentage of mitochondrial reads (often above 10 to 20%) flags a dying cell. These cells should be removed.

Doublets occur when two cells are captured in the same droplet. They appear as cells with unusually high gene counts and mixed identity. Tools for doublet detection include:

• scDblFinder (R): fast simulation-based method
• Scrublet (Python): uses simulated doublets to score real cells

A typical QC step filters cells based on three metrics: total UMI counts, number of genes detected, and mitochondrial read percentage.

3. Normalization

Raw counts are not directly comparable between cells. A cell sequenced more deeply will have higher counts for every gene. Normalization corrects for differences in sequencing depth.

Common approaches:

• Log-normalization: divide each cell’s counts by its total, multiply by a scale factor of 10,000, then take the natural log. Simple and widely used.
• SCTransform: a variance-stabilizing transformation from the Seurat package. Uses regularized negative binomial regression. Handles the mean-variance relationship better than log-normalization.
• scran pooling: pools cells into groups, estimates size factors from the pooled counts, then deconvolves back to individual cells. Available in the scran R package.

4. Feature selection

Most genes show little variation across cells. They add noise without contributing information. Feature selection identifies the 1,000 to 3,000 most variable genes for downstream analysis.

These highly variable genes (HVGs) are the ones that differ most between cell types. All subsequent steps use only these genes, which reduces noise and speeds up computation.

5. Dimensionality reduction

Even after selecting HVGs, the data has thousands of dimensions. Dimensionality reduction makes it manageable.

PCA is always the first step. It reduces the data to 10 to 50 principal components that capture the main axes of variation. PCA output is used for clustering and further visualization.

UMAP and tSNE reduce the PCA output to two dimensions for plotting. These are visualization tools only. Do not interpret distances on a UMAP or tSNE plot as biological distances. Clusters that appear close on a UMAP may not be similar, and clusters that appear far apart may be related.

Caution

UMAP and tSNE are for visualization, not for quantitative analysis. Never cluster cells based on their UMAP coordinates. Always cluster in PCA space.

6. Clustering

Clustering groups cells with similar expression profiles. The standard approach is graph-based clustering.

The algorithm builds a nearest-neighbor graph in PCA space. Each cell is a node. Edges connect cells to their closest neighbors. Then a community detection algorithm partitions the graph into clusters.

Common algorithms:

• Louvain: fast, widely used, the default in many tools
• Leiden: improved version of Louvain, produces better-connected communities

The resolution parameter controls how many clusters you get. Higher resolution produces more clusters. There is no single correct resolution. The right choice depends on your biological question.

7. Cell type annotation

Clusters are numbered, not named. You need to assign biological identities. This is one of the hardest and most subjective steps.

Manual annotation uses known marker genes. For example:

• CD3D, CD3E: T cells
• CD14, LYZ: monocytes
• MS4A1, CD79A: B cells
• NKG7, GNLY: NK cells
• PPBP: platelets

You examine which markers are enriched in each cluster and assign labels based on domain knowledge.

Automated annotation uses reference datasets:

• SingleR (R): compares each cell to a labeled reference dataset and transfers labels
• CellTypist (Python): uses pre-trained models for common tissue types
• Azimuth (R/web): reference-based mapping from the Seurat team
• scType: uses a curated database of cell type markers

Tip

No single annotation method is perfect. Best practice is to use multiple methods and validate with known marker genes. Always report which method and reference you used.

8. Downstream analysis

Once cells are annotated, you can ask deeper biological questions.

Differential expression identifies genes that differ between conditions. The recommended approach is pseudobulk analysis. Aggregate counts by sample and cell type, then use DESeq2 or edgeR. See the Key Challenges page for why this matters.

Trajectory analysis reconstructs developmental paths. Tools include Monocle 3, Slingshot, and scVelo for RNA velocity.

Cell-cell communication predicts which cell types signal to each other. Tools include CellChat, LIANA, and NicheNet.

Main analysis frameworks

Two frameworks dominate scRNA-seq analysis. Most published studies use one of these.

Seurat (R)

Seurat is the most widely used scRNA-seq framework. It is an R package developed by the Satija Lab at the New York Genome Center.

Key features:

• Complete workflow from raw counts to publication figures
• Large ecosystem of extensions and integrations
• Uses the Seurat object to store data, metadata, reductions, and results
• Excellent documentation and vignettes
• Integration methods: CCA, RPCA, and Harmony via addon

Scanpy (Python)

Scanpy is the main Python framework. It is built around the AnnData object.

Key features:

• AnnData stores the count matrix, metadata, and computed results in a single object
• Integrates with scvi-tools for deep learning methods (scVI, scANVI, CellAssign)
• Fast and memory-efficient for large datasets
• Extensive visualization functions
• Strong integration with the broader Python data science ecosystem

Bioconductor SingleCellExperiment

The Bioconductor ecosystem uses the SingleCellExperiment object. It offers more modular packages. Instead of one framework doing everything, you combine packages like scran, scater, batchelor, and bluster. This approach is more flexible but requires assembling the pipeline yourself.

Seurat vs Scanpy comparison

Feature	Seurat (R)	Scanpy (Python)
Language	R	Python
Data structure	Seurat object	AnnData (.h5ad)
Community size	Largest	Second largest, growing fast
Deep learning integration	Limited	Excellent (scvi-tools)
Visualization	ggplot2-based	matplotlib/scanpy built-in
Large dataset handling	Good	Better for very large datasets
Documentation	Extensive vignettes	Good tutorials
Publication standard	Most cited	Increasingly common

nf-core pipelines

The nf-core community provides a standardized Nextflow pipeline for the raw data processing step.

nf-core/scrnaseq takes FASTQ files and produces a count matrix. It supports multiple aligners:

• Cell Ranger
• STARsolo
• Salmon Alevin (with AlevinQC)
• Kallisto Bustools

The pipeline handles sample demultiplexing, alignment, barcode correction, and quality metrics. Using nf-core/scrnaseq ensures reproducible preprocessing regardless of which aligner you choose.

Note

nf-core/scrnaseq handles only the first step of the workflow: FASTQ to count matrix. All downstream analysis (QC filtering, normalization, clustering, annotation) is done in Seurat or Scanpy.

Putting it all together

Here is the full workflow from sample to results:

1. Sequencing facility delivers FASTQ files
2. nf-core/scrnaseq or Cell Ranger converts FASTQs to a count matrix
3. Seurat or Scanpy handles QC, normalization, clustering, and annotation
4. Downstream tools answer specific biological questions (DE, trajectories, communication)

Each step builds on the previous one. The choices you make early in QC and normalization affect everything downstream. The next page covers the key challenges you will face at each step.

Recommended resources

If you want to go deeper into single-cell analysis, these are the best starting points.

• Seurat tutorials: The official Seurat website has step-by-step vignettes covering the full R workflow. Start with the “Guided Clustering Tutorial” for a standard PBMC analysis.

• Scanpy tutorials: The Scanpy documentation includes tutorials that mirror the Seurat workflow in Python. The “Preprocessing and clustering 3k PBMCs” tutorial is the standard starting point.

• Single-cell best practices: This is the most comprehensive reference for single-cell analysis. It covers every step of the workflow using the best tools from both R and Python. It explains not just how to run the tools, but why each step matters and what can go wrong. If you read one resource on single-cell analysis, make it this one.