Key takeaways: An AAV sequencing request runs on four inputs: (1) a correct reference sequence + AAV vector map (including ITR definitions), (2) a precise sample type definition (what exactly is being sequenced), (3) explicit comparison groups and controls (what "different" means), and (4) a list of AAV sequencing readouts tied to your research question (identity, ITR structure, integrity, variants, impurities). When any of these are incomplete, the analysis often becomes under-powered, non-comparable, or impossible to interpret.

Research Use Only (RUO): This article discusses research study design and sequencing strategy. It is not intended for clinical diagnosis, treatment decisions, or individual health assessment.

1. Introduction: Why incomplete AAV project information causes analysis and interpretation problems

Most "AAV sequencing problems" are not sequencing problems.

They're scoping problems.

When a project intake is missing a definitive vector reference, unclear about what sample type is being sequenced, or vague about the readouts required, the downstream analysis becomes fragile in predictable ways:

• Identity vs impurity confusion: a sequence that looks like a rearrangement may actually be packaged plasmid backbone or helper DNA—if those references were never provided.
• ITR ambiguity: inverted terminal repeats are structurally challenging and often require special handling; if the ITRs are not defined and annotated, "ITR issues" become indistinguishable from mapping artifacts or incomplete coverage.
• Integrity metrics that don't answer the decision: a report can quantify truncations, rearrangements, and junction correctness, but if you didn't define which junctions matter and what constitutes a meaningful deviation, it's hard to turn results into decisions.
• Non-comparable batches: batch-to-batch comparisons fail when the reference build, sample handling, library method, or analysis rules differ between groups.

This guide is a practical "pre-project checklist" for teams ready to scope an AAV sequencing project. It focuses on what you must prepare—vector map, samples, comparisons, controls, and required readouts—and how each choice affects interpretability.

2. Start with the research question

Before you send any samples, write down your research question in one sentence.

Then force it into one of the buckets below. Each bucket implies a different minimum reference package, sample material, comparison design, and analysis workflow.

Identity confirmation

Typical question: "Is this the vector genome we think it is?"

What this drives:

• You need an unambiguous reference sequence (not a schematic).
• You need to define whether identity means cassette-level identity (promoter→polyA) or ITR-to-ITR identity.
• You should specify whether you care about rare variants (low-frequency SNVs) or only consensus identity.

Common interpretability failure: Identity is requested, but the intake lacks the exact reference (or includes an outdated plasmid version), so every detected difference is ambiguous.

ITR characterization

Typical question: "Are the ITRs intact? Are there ITR variants or deletions?"

What this drives:

• You must provide the expected ITR sequences and boundaries (start/end coordinates).
• You should expect that ITR readouts are sensitive to platform and library preparation. Short-read workflows can struggle to fully resolve ITR structure because of secondary structure, repetitive sequence features, and library-preparation bias.

Common interpretability failure: The vector map labels "ITR" but doesn't define which ITR (AAV2? engineered?) or the exact sequence. The analysis can't distinguish true ITR mutations from mapping uncertainty.

Genome integrity

Typical question: "What fraction of packaged genomes are full-length vs truncated or rearranged?"

What this drives:

• Integrity readouts require you to define what counts as "full-length" (e.g., ITR-to-ITR span, minimum aligned length, identity threshold).
• Molecule-level approaches (long reads) are often chosen for integrity questions because they preserve end-to-end structure.

Common interpretability failure: Project requests "integrity" but provides only a transgene region reference; you can't localize truncations without a full construct reference.

Variant detection

Typical question: "Are there SNVs/indels in the cassette or ITRs, and at what frequency?"

What this drives:

• You must define the variant regions (whole genome vs specific junctions vs transgene only).
• You must define whether you need quantitative variant allele frequency (VAF) reporting and the evidence thresholds.

Common interpretability failure: Variant detection is requested, but no comparator is defined (e.g., plasmid reference, prior batch), so it's unclear whether variants are new, expected, or irrelevant.

Contamination analysis

Typical question: "What unintended DNA species are present (host-cell DNA, plasmid backbone, helper plasmids), and at what levels?"

What this drives:

• You need a multi-reference set: vector reference + production plasmids (rep/cap, helper) + backbone + host reference.
• You need to specify whether contamination means non-encapsidated carryover or encapsidated DNA impurities.

Interpretation improves when exact ITR boundary coordinates and all relevant production plasmid references are included.

Batch comparison

Typical question: "Are two batches/process conditions meaningfully different?"

What this drives:

• You must define comparability: which metrics (full-length fraction, impurity fraction, specific junction correctness, variant rates) and what magnitude of change matters.
• You need consistent references, consistent metadata, and ideally a defined normalization strategy.

Common interpretability failure: Teams submit batches months apart without frozen references or consistent metadata, then attempt a "difference" call with no baseline.

3. Prepare the vector map and reference files

AAV sequencing is reference-driven. Even when performing assembly, your ability to interpret outcomes hinges on knowing the intended construct and its boundaries.

Below is what to prepare, and why each element matters.

Complete reference sequence

Required

• The exact intended vector genome sequence used for design decisions (FASTA preferred).
• Version control: sequence name, version/date, and who approved it.

Recommended

• A second reference that reflects the plasmid sequence used for production (if different from the intended genome sequence).
• A checksum/hash for the reference FASTA (helps ensure everyone is using the same file in comparisons).

Why it matters: Without a stable reference, you can't distinguish true changes from reference drift.

ITR annotations

Required

• Exact ITR start/end coordinates in the reference.
• Identify ITR type (e.g., AAV2 ITR or engineered variant).

Recommended

• If you have prior ITR QC results (plasmid ITR sequencing, restriction digest patterns), include them as context.

Why it matters: ITRs are structurally difficult and prone to deletions/mutations; if ITR boundaries are not defined, ITR-related findings often collapse into ambiguity ("could be artifact").

Promoter, transgene, regulatory elements, and backbone regions

Required

• Annotate key regions:

  • promoter/enhancer
  • introns/splice sites (if present)
  • transgene/coding sequence
  • regulatory elements (WPRE, insulators, etc.)
  • poly(A) signal

Recommended

• Explicitly annotate vector backbone risk regions: any sequences that should not be packaged (bacterial origin, antibiotic resistance marker, etc.).

Why it matters: Many AAV genome analysis deliverables become actionable only when they are feature-aware. A truncation that removes a promoter boundary is different from one that occurs in a non-coding spacer—your map enables interpretation.

ssAAV vs self-complementary AAV

Required

• Specify whether the product is single-stranded AAV (ssAAV) or self-complementary AAV (scAAV).

Recommended

• Provide expected genome size, including any stuffer sequence.

Why it matters: The expected genome architecture changes how you interpret length distributions, junctions, and potential snap-back structures.

Figure 2. Annotated AAV vector map showing the intended ITR-to-ITR genome and the construct regions that should be defined before sequencing and bioinformatics analysis.

4. Define the sample type

One of the fastest ways to derail an AAV sequencing project is to treat "AAV sample" as a single category.

Define what you are sending and what it represents biologically.

Pro Tip: If you're outsourcing, include a one-line statement per sample: "This material is intended to represent encapsidated genomes from batch X after purification step Y." It prevents downstream assumptions.

Purified vector particles

Typical use: "What's packaged inside the capsid population?"

Required project details

• Purification context (high-level): what stage (post-purification drug substance, in-process intermediate).
• Any nuclease treatment policy (e.g., DNase used to remove non-encapsidated DNA) and how it was inactivated.

Interpretation note: Encapsidated impurity findings depend on whether non-encapsidated DNA was removed.

Extracted nucleic acid

Typical use: "We can ship extracted DNA; sequence it."

Required project details

• What extraction method was used (kit or method name).
• Whether you enriched for encapsidated genomes vs total DNA.

Interpretation note: Extraction can bias toward shorter fragments, which can distort integrity estimates; you should ask how integrity will be computed (read-level vs molecule-level) and how bias is handled.

Plasmid or production intermediates

Typical use: "Confirm plasmid identity and ITRs before packaging; compare plasmid vs packaged DNA."

Required project details

• Plasmid IDs and which one corresponds to the transfer vector.
• Whether helper/rep-cap plasmids should be included as references (strongly recommended for impurity analysis).

Why it matters: Plasmid validation reduces the risk of interpreting plasmid-derived issues as production-derived issues.

Cell or tissue samples

Typical use: Integration site questions, biodistribution-associated vector DNA questions.

Required project details

• What organism/cell type and treatment context.
• Whether the question is integration-site profiling vs presence/identity of vector DNA.

Interpretation note: The reference set and analysis approach differ substantially from "vector genome integrity" projects.

Sequencing-ready libraries

Typical use: "We already prepared libraries; run sequencing + analysis."

Required project details

• Library method, enrichment/amplicon design (if any), cycle counts.
• Whether indexes are unique and how samples are pooled.

Interpretation note: If the library was built with targeted amplicons, you cannot infer whole-genome integrity without gaps.

Internal resource: If you need a concrete example of how providers summarize AAV sequencing sample requirements, CD Genomics' overview page can serve as a template for what to include in your own manifest: AAV sequencing.

5. Define the comparison groups

AAV sequencing becomes decision-grade when it is comparative.

Define comparison groups explicitly—even if the comparator is "the plasmid reference."

Batch-to-batch comparison

Required

• What constitutes a batch: DS lot, DP lot, purification lot, or fill-finish lot.
• Which batch is baseline vs test.

Recommended

• Frozen aliquots of a baseline reference batch to allow reruns.

Process-condition comparison

Examples

• Purification change: gradient vs chromatography
• Nuclease policy change: with vs without treatment
• Host system change: different production cell line

Required

• One change per comparison whenever possible (avoid "everything changed at once").

Reference plasmid comparison

Required

• Define whether the plasmid is treated as "ground truth" or just a comparator.

Recommended

• Include helper and rep/cap plasmids in the reference set for impurity assignment.

Stability or longitudinal comparison

Required

• Timepoints, storage conditions, and handling conditions.

Recommended

• Define what "drift" means: increase in truncation fraction, emergence of a hotspot, increase in impurity fraction, etc.

6. Select required readouts

Don't request "full analysis." Request readouts tied to your research question.

Below is a practical menu of AAV sequencing readouts for project scoping.

Sequence identity

What it answers: Does the consensus match the intended construct?

Required inputs

• Reference sequence.

Recommended additions

• Explicit definition of pass/fail regions (cassette-only vs ITR-to-ITR).

SNVs and indels

What it answers: Are there point mutations or small indels, and where?

Required inputs

• Regions to call variants on.
• Variant reporting format needed (table, VCF).

Interpretation caution: Platform error profiles differ. For example, nanopore long reads can span ITR-to-ITR but have known indel-heavy error profiles without correction, which impacts small-variant certainty (see 2022 evidence and limitations in Direct ITR-to-ITR nanopore sequencing of AAV vectors).

ITR structure

What it answers: Are ITRs intact and structurally consistent?

Required inputs

• ITR definitions and boundaries.

Recommended additions

• A decision about whether you need ITR-specific confirmation (e.g., targeted long reads) vs general integrity context.

Full-length genome integrity

What it answers: What fraction of genomes are full-length?

Required inputs

• Definition of "full-length" and allowed mismatch.

Recommended additions

• Comparative baseline.

Long-read integrity profiling methods are widely used to quantify full-length vs truncated genomes and to localize breakpoints. One example is the SMRT-based "AAV genome population sequencing (AAV-GPseq)" described by Tran et al., 2020 (PMC7397707).

Truncations and rearrangements

What it answers: Where do genomes break, and are there inversions/duplications/junctions?

Required inputs

• Feature annotations to interpret impact.

Recommended additions

• Junction list to validate: promoter boundary, splice sites, coding junctions, polyA.

A pragmatic reporting approach is to include a breakpoint landscape and a junction correctness table with evidence plots. (One example of an explicit reporting framework is described in a 2026 CD Genomics guidance article on AAV genome integrity metrics.)

Vector-backbone sequences

What it answers: Are backbone sequences being packaged?

Required inputs

• Backbone reference (complete plasmid sequence).

Interpretation caution: Without the correct backbone reference and correct ITR boundary coordinates, backbone reads can be misclassified or overcalled.

Host-cell or plasmid contamination

What it answers: What unintended DNA species are present, and in what fraction?

Required inputs

• Host system and appropriate host reference.
• Production plasmid references (helper, rep/cap) if you want classification.

Recommended additions

• Define whether you want a taxonomy (host vs plasmid vs other viral) and what reporting granularity.

Related resource: For a platform/workflow overview you can use to align expectations in a statement of work, see CD Genomics' explainer on AAV sequencing workflows and platforms.

7. Match research questions to sequencing readouts in a table

Research question (what you need to decide)	Minimum readouts	Required inputs	Common ambiguity if missing
Identity confirmation	Consensus identity + coverage plot	Reference FASTA + feature annotations	Differences can't be assigned (true change vs reference mismatch)
ITR characterization	ITR structure summary + ITR boundary evidence	Exact ITR sequences + coordinates	ITR issues collapse into "mapping artifact"
Genome integrity	Full-length fraction + genome length distribution	Full reference + full-length definition	"Integrity" becomes subjective; hard to compare batches
Truncations/rearrangements	Breakpoint landscape + junction table	Feature map + junction list	Breaks can't be interpreted for functional impact
Variant detection	SNV/indel table (with region scope)	Defined variant regions + evidence thresholds	False positives/negatives from platform/pipeline not understood
Contamination analysis	Impurity profile (multi-reference)	Host + helper/repcap + backbone references	Backbone/helper reads mistaken for rearrangements
Batch comparison	Side-by-side metrics + delta table	Same references + consistent metadata	Differences may reflect workflow drift, not biology

Figure 3. Workflow connecting common AAV sequencing research questions with the reference files, samples, controls, and report outputs required to answer them.

8. Controls and metadata to prepare

Treat controls and metadata as first-class deliverables. They're what make sequencing results interpretable across time and across organizations.

Controls

Required (minimum)

• Negative control definition (what "no vector" means for your workflow).
• Baseline comparator definition (even if it's a prior batch).

Recommended

• Technical replicate strategy (what is replicated: extraction, library, sequencing).
• A plan for how "evidence grade" will be assigned if readouts conflict (e.g., structural vs small-variant calls).

Metadata

Required

• Sample IDs with unambiguous mapping to batch/process.
• Host system (cell line/species) and production context.
• Library method or "provider to prepare library" instruction.

Recommended

• Storage conditions and time since production.
• Nuclease treatment details (policy-level).
• Any known construct risks (near-capacity genomes, repeats, high GC elements).

9. Questions that affect platform and workflow selection

The right workflow depends on the research question. These scoping questions change platform choice and analysis design.

1. Do you need ITR-to-ITR structure, or is cassette-only sufficient?
2. Is the main goal small variants (SNVs/indels) or structural integrity (truncations/rearrangements)?
3. Do you expect heterogeneity (mixed populations), or is this a clonal plasmid confirmation?
4. Do you need quantitative impurity fractions, or only presence/absence screening?
5. Is this a comparison study (batch/process/stability), and do you need strict cross-run comparability?
6. What is the sample material: encapsidated genomes, extracted DNA, plasmid, tissue gDNA, or prepared libraries?

⚠️ Warning: If you don't define whether your primary risk is "missing low-frequency variants" or "missing structural heterogeneity," it's easy to choose a workflow that produces a technically correct report—but the wrong kind of evidence for your decision.

10. What should be included in a project intake package

Below is a practical intake package you can send to a sequencing provider or CRO.

Required

• Project goal statement (1–3 sentences) + which bucket(s) it falls into (identity, ITR, integrity, variants, contamination, comparison).
• Vector reference FASTA (intended genome) + version label.
• Vector map (GenBank or annotated PDF) including ITR coordinates and feature annotations.
• Sample manifest: sample IDs, sample type, batch/process metadata, requested comparisons.
• Readouts list: explicit deliverables requested (identity, SNVs, ITR structure, integrity, truncations/rearrangements, backbone, contamination).

Recommended

• Production plasmid sequences (transfer vector plasmid + helper + rep/cap) if impurity classification matters.
• Host reference information (host genome build or at least host species/cell line).
• Known risk notes: near-capacity genomes, repeats, high GC promoter, engineered ITRs.
• Decision thresholds (project-defined): what changes would trigger follow-up (confirmatory assays, re-run, process investigation). A useful approach is to define targets and "Proceed / Confirm / Fix" triggers.

Optional

• Prior run reports for the same vector (for comparability).
• Any orthogonal QC results (digital PCR targets, restriction digest patterns, capsid content assays).

11. Common submission and scoping mistakes

1. Providing an AAV vector map without the underlying reference sequence.
2. Using "ITR" placeholders instead of exact ITR sequences and boundaries.
3. Asking for integrity without defining "full-length".
4. Requesting contamination analysis but not including helper/backbone references.
5. Submitting samples with no comparison plan ("analyze these 6 samples" without baseline/test definitions).
6. Mixing multiple process changes in one comparison and then expecting root-cause attribution.
7. Treating a targeted amplicon library as whole-genome evidence.
8. Not asking for evidence artifacts (coverage plots, breakpoint tables, junction-read evidence) and receiving only summary statements.

12. Expected project outputs (AAV sequencing project design deliverables)

You should expect deliverables that allow both a quick decision and a deeper audit trail.

Minimum outputs (recommended)

• A methods summary describing sample type, reference build used, and analysis scope.
• Sequence identity summary + annotated coverage plot.
• Variant table (if requested) with genomic positions and region labels.
• ITR readout (structure summary and evidence notes) when in scope.
• Integrity package: full-length fraction definition + results, genome length distribution, breakpoint landscape.
• Impurity/contamination profile: host vs plasmid vs other categories, tied to the reference set used.

13. Project preparation checklist (AAV sequencing checklist for project design)

Use this AAV sequencing checklist as a final pre-submission gate.

A. Research question and success criteria

• Required: We wrote the primary research question in one sentence.
• Required: We selected the primary goal bucket(s): identity / ITR / integrity / variants / contamination / comparison.
• Recommended: We defined what decision will be made from the result (release, comparability, root-cause, stability).

B. Vector map and references

• Required: Full reference sequence (FASTA) + version label.
• Required: Vector map with feature annotations + ITR coordinates.
• Recommended: Full plasmid sequence(s) including backbone, and helper/repcap sequences if impurity analysis is required.
• Optional: Prior plasmid ITR QC evidence.

C. Samples

• Required: Sample type clearly defined (purified particles vs extracted DNA vs plasmid vs tissue/cells vs libraries).
• Required: Sample manifest with IDs linked to batch/process metadata.
• Recommended: Replicate strategy defined (what is replicated).

D. Comparison groups

• Required: Baseline vs test groups explicitly defined.
• Recommended: One process variable per comparison (when possible).
• Optional: Longitudinal plan (timepoints + storage conditions).

E. Readouts

• Required: Requested readouts listed explicitly (identity, SNVs/indels, ITR structure, integrity, truncations/rearrangements, backbone, contamination).
• Recommended: Junction list to validate (promoter boundary, splice sites, polyA, etc.).
• Optional: Project-defined triggers for follow-up ("confirmatory assays / rerun / process investigation").

14. Conclusion

An AAV sequencing project is only as interpretable as its reference package, sample definition, comparison logic, and readout list.

If you prepare those inputs up front—especially ITR definitions, backbone/production plasmid references for impurity assignment, and a clear comparison baseline—you'll get a report that supports decisions instead of creating new ambiguity.

If you want to sanity-check your intake package before submitting, a low-friction approach is to share: (1) the vector map + reference FASTA, (2) the sample manifest and comparison design, and (3) the required readouts tied to your research question.

Brand note: CD Genomics supports AAV genome analysis projects for research use.

15. FAQ

1) Do I need to provide a GenBank file, or is a PDF vector map enough?

A PDF map is helpful, but a GenBank (or equivalent annotated sequence) plus a reference FASTA is what makes analysis unambiguous. The annotation layer allows results to be reported in biologically meaningful terms ("promoter junction," "polyA boundary," "ITR-adjacent hotspot") instead of just raw coordinates.

2) Why are ITRs called out separately in AAV sequencing project design?

ITRs have strong secondary structure and repetitive features that can reduce sequencing and mapping reliability, especially for short-read workflows. If you don't define ITR boundaries and decide how ITR evidence will be generated, ITR-related findings often collapse into ambiguity ("could be artifact").

3) When is long-read sequencing the right choice?

Long reads are most useful when you need molecule-level structure: ITR-to-ITR spans, truncation hotspots, rearrangements, and genome–contaminant fusions. They're frequently selected for integrity questions and for characterizing heterogeneity that cannot be reconstructed confidently from short fragments.

4) When are short reads sufficient?

Short reads are often sufficient for high-confidence consensus identity on well-behaved regions and for deep quantification of small variants or low-level impurities—provided you define the scope (which regions) and supply the right references for classification.

5) Should I sequence the plasmids used for production as part of the same project?

If your goal includes impurity assignment, variant root-cause, or troubleshooting integrity, sequencing production plasmids (transfer vector plasmid and, when relevant, helper/repcap) can reduce ambiguity. It helps separate "design/plasmid-derived" issues from "packaging/production-derived" issues.

6) What's the single most common reason batch comparisons fail?

Inconsistent inputs. If batches are sequenced with different reference versions, different library methods, or different metadata completeness, apparent differences can be workflow drift rather than real product changes. Comparisons become far more reliable when the reference build and metric definitions are frozen.

7) How should I define "full-length" in an AAV genome analysis readout?

Define it in operational terms: which endpoints (often ITR-to-ITR), what minimum aligned length qualifies, and what mismatch/indel tolerance is acceptable. Then make sure the report includes both the definition and the evidence artifacts (length distribution and breakpoint summary), so decisions aren't dependent on a single summary number.

8) What should I ask for in the final report to make it auditable?

Ask for a package that includes: annotated coverage plots, breakpoint/junction tables, an impurity profile tied to the reference set used, and a methods appendix with pipeline versions and key parameters. These artifacts let you review and explain outcomes internally without relying on vague conclusions.