Tools I Learned: A Bioinformatics Toolkit for Viral Genomics

A beginner's guide to essential bioinformatics tools for viral genome analysis—what each does, when to use them, and lessons from analyzing SARS-CoV-2

The Toolbox Problem

When I started my SARS-CoV-2 genomic analysis project, I faced a overwhelming question: Which tools do I use for what?

Bioinformatics has hundreds of tools. BLAST, SPAdes, Prokka, MUSCLE, FastTree, LSD2, BioCyc, QUAST, Taxonium... the names alone were intimidating. Worse, many tools do similar things (5+ different genome assemblers! 10+ alignment tools!), and choosing the wrong one can waste hours or give wrong results.

Coming from a wet-lab background where I used the same equipment for years (my trusty thermal cycler, UV transilluminator, pipettes), the bioinformatics toolkit felt chaotic and ever-changing.

This blog is the guide I wish I had when I started. I'll walk through the 15 essential tools I used to analyze SARS-CoV-2 genomes—from raw sequencing reads to drug target discovery—explaining what each does, when to use it, and the mistakes I made so you don't have to.

Think of this as your bioinformatics toolkit reference card—bookmark it, refer back, and use it when you're stuck wondering "Wait, which tool do I use for this?"

The Workflow: Tools by Analysis Stage

Before diving into individual tools, here's the big picture—the complete workflow I used and where each tool fits:

Raw Sequencing Data (FASTQ)
    ↓
[SPAdes] → Genome Assembly
    ↓
[QUAST] → Quality Assessment
    ↓
[Prokka] → Gene Annotation
    ↓
[BLAST] → Homology Search
    ↓
[MUSCLE] → Multiple Sequence Alignment
    ↓
[FastTree] → Phylogenetic Tree
    ↓
[LSD2] → Molecular Clock Dating
    ↓
[BioCyc] → Pathway Analysis
    ↓
Drug Target Discovery

Each arrow represents a tool transforming data from one form to another. Let's break down each tool.

🔧 PART 1: Assembly & Quality Control

1. SPAdes — The Genome Assembler

What it does: Reconstructs complete genomes from millions of short DNA reads using de Bruijn graph algorithms.

When to use it: - You have Illumina paired-end sequencing data - You want de novo assembly (no reference genome) - Genome size: bacterial/viral (works best for <100 Mb)

My use case: Assembled 2.5 million SARS-CoV-2 reads into a 29,903 bp genome.

Key parameters:

spades.py \
  -1 forward_reads.fastq \
  -2 reverse_reads.fastq \
  -o output_directory \
  -k 21,33,55  # Multiple k-mer sizes

What I learned: - Multiple k-mers are essential: SPAdes automatically tries different k-mer sizes (21, 33, 55). Small k-mers handle low coverage, large k-mers resolve repeats. - Takes time: My 30kb viral genome took 45 minutes. Larger genomes take hours to days. - RAM hungry: Needs 16+ GB for bacterial genomes. Galaxy servers handle this for you.

Common mistakes: - Using only single-end reads (paired-end gives much better results) - Not checking error correction (--careful flag improves accuracy) - Running out of memory (use --memory parameter)

Output files: - contigs.fasta — Your assembled genome! - scaffolds.fasta — Contigs joined by N's - assembly_graph.fastg — The actual de Bruijn graph

Alternatives: MEGAHIT (faster, less accurate), Unicycler (hybrid assembly), Canu (long reads)

Installation: Available in Galaxy, or conda install spades

Documentation: http://cab.spbu.ru/software/spades/

2. QUAST — The Quality Police

What it does: Evaluates genome assembly quality with detailed statistics.

When to use it: - Immediately after assembly (every time!) - Comparing multiple assemblies - Checking if assembly meets publication standards

My use case: Verified my SARS-CoV-2 assembly had N50 of 29,903 bp (perfect!), correct GC%, and minimal contamination.

Key metrics QUAST reports:

Number of contigs: 3
Largest contig: 29,903 bp
Total length: 30,121 bp
N50: 29,903 bp
GC%: 37.97%

What each metric means: - N50: Length of contig at 50% cumulative assembly length (higher = better) - Largest contig: Your best assembled piece - # of contigs: Fewer = better (ideally 1 for small genomes) - GC%: Should match expected value (~38% for SARS-CoV-2)

What I learned: - N50 is king: Single most important quality metric. My 29,903 bp N50 meant almost the entire genome in one piece. - Compare to reference: Use -r reference.fasta to get detailed alignment statistics - Watch for contamination: Extra small contigs with low coverage are usually contamination

Common mistakes: - Not running QUAST (never skip quality assessment!) - Misinterpreting N50 (it's not average contig length) - Ignoring GC% deviation (big difference = problem)

Quick command:

quast.py contigs.fasta -o quast_results

Alternatives: assembly-stats, Bandage (visualization)

Installation: Galaxy, or conda install quast

🧬 PART 2: Annotation & Gene Finding

3. Prokka — The Gene Finder

What it does: Automatically annotates bacterial/viral genomes—finds genes, predicts functions, identifies proteins.

When to use it: - You have an assembled genome - You want to know: Where are the genes? What do they do? - Working with prokaryotes or viruses (not eukaryotes)

My use case: Identified all 11 SARS-CoV-2 genes (ORF1ab, spike, envelope, membrane, nucleocapsid, etc.) and predicted their functions.

What Prokka finds: - Open Reading Frames (ORFs) - tRNA genes - rRNA genes - Signal peptides - Protein functions (by homology)

Key parameters:

prokka \
  --kingdom Viruses \
  --genus Betacoronavirus \
  genome.fasta \
  --outdir prokka_output

Output files: - .gff — Gene locations (standard format) - .faa — Protein sequences (amino acids) - .ffn — Gene sequences (nucleotides) - .gbk — GenBank format (for visualization)

What I learned: - Kingdom matters: Use --kingdom Viruses for viruses, Bacteria for bacteria - Quick results: Annotated 30kb SARS-CoV-2 genome in ~2 minutes - Gene names are predictions: Cross-check with BLAST for important genes

Common mistakes: - Using eukaryotic genomes (Prokka is prokaryote/virus only) - Not specifying kingdom (reduces accuracy) - Trusting predictions blindly (always validate key genes)

Real example from my project:

Prokka found:
- ORF1ab: 7,096 amino acids (polyprotein)
- Spike: 1,273 amino acids (receptor binding)
- N gene: 419 amino acids (nucleocapsid)
Total: 11 ORFs identified

Alternatives: RAST (bacteria), GeneMarkS, Glimmer

Installation: conda install prokka

Documentation: https://github.com/tseemann/prokka

4. BLAST — The Homology Detective

What it does: Finds similar sequences in databases—answers "What is this sequence similar to?"

When to use it: - Identifying unknown sequences - Finding closest relatives - Validating assembly/annotation - Designing specific primers

My use cases: 1. Validated assembly: BLASTed my assembled genome → 99.99% match to Wuhan-Hu-1 reference 2. Found closest relative: BLASTed against pre-2020 viruses → Bat coronavirus RaTG13 (96.1% identity) 3. Checked primer specificity: BLASTed primer sequences against human genome

BLAST flavors: - blastn: DNA vs DNA (what I used most) - blastp: Protein vs protein - blastx: DNA translated to protein vs protein database - tblastn: Protein vs DNA database (translated)

Key parameters:

blastn \
  -query my_sequence.fasta \
  -db nt \  # NCBI nucleotide database
  -outfmt 6 \  # Tabular output
  -max_target_seqs 10  # Top 10 hits

What I learned: - Database choice matters: - nt = all nucleotides (huge, slow) - nr = all proteins - Custom databases for specific searches - E-value is key: Lower = better. E < 1e-10 is significant. E > 0.01 is probably noise. - Filter by date: I used entrez query to exclude SARS-CoV-2 sequences when finding closest relative

Common mistakes: - Not filtering results (too many irrelevant hits) - Ignoring E-value (low similarity hits) - Wrong database (viral query against bacterial database)

Real results:

Top BLAST hit:
Query Coverage: 100%
Percent Identity: 99.99%
E-value: 0.0
Match: SARS-CoV-2 isolate Wuhan-Hu-1

Web version: https://blast.ncbi.nlm.nih.gov/Blast.cgi

Installation: conda install blast

🌳 PART 3: Comparative Analysis & Phylogenetics

5. MUSCLE — The Alignment Tool

What it does: Aligns multiple DNA or protein sequences to identify conserved regions and differences.

When to use it: - Comparing 3+ sequences - Finding conserved/variable regions - Preparing data for phylogenetic analysis

My use case: Aligned SARS-CoV-2 spike protein with SARS-CoV-1 and RaTG13 to identify key mutations in receptor-binding domain.

How it works:

Unaligned sequences:
Seq1: ATCGATCG
Seq2: ATC--TCG
Seq3: ATCGAACG

MUSCLE aligns:
Seq1: ATCGATCG
Seq2: ATC--TCG
Seq3: ATCGAACG
      *** * **  (conserved positions)

Key parameters:

muscle \
  -in unaligned.fasta \
  -out aligned.fasta \
  -maxiters 16  # More iterations = better alignment

What I learned: - Protein vs DNA: Protein alignments more reliable for divergent sequences - Gaps matter: Insertions/deletions (indels) are biologically meaningful - Check by eye: Always visualize alignment (use Jalview)

Key findings from my alignment: - 6 critical mutations in spike RBD compared to SARS-CoV-1 - Furin cleavage site (PRRA) absent in RaTG13 - ~90% amino acid identity in spike protein

Common mistakes: - Aligning too-divergent sequences (< 30% identity doesn't align well) - Not trimming poorly aligned regions - Forgetting to specify sequence type (DNA vs protein)

Alternatives: MAFFT (faster), Clustal Omega, T-Coffee

Installation: conda install muscle

Visualization: Use Jalview or MEGA to view alignments

6. ViralMSA — Viral Genome Aligner

What it does: Specialized multiple sequence alignment tool optimized for viral genomes (especially SARS-CoV-2).

When to use it: - Aligning full viral genomes (not just genes) - Working with large datasets (100+ sequences) - Need fast alignment of closely related sequences

My use case: Aligned 100 complete SARS-CoV-2 genomes spanning January 2020–March 2023 for phylogenetic analysis.

Why use ViralMSA instead of MUSCLE: - Speed: 100 genomes in minutes vs hours - Viral-optimized: Handles common viral features (recombination, high mutation rates) - Integration: Works with Minimap2 (ultra-fast aligner)

Command:

ViralMSA.py \
  -s sequences.fasta \
  -r reference.fasta \
  -e email@example.com \
  -o output_directory

What I learned: - Reference-guided: Uses reference genome to guide alignment (faster, more accurate for similar sequences) - Automatic trimming: Removes poorly aligned ends - Position filtering: Excludes positions with excessive gaps

Output: Aligned sequences ready for phylogenetic analysis

Installation: pip install viralmsa

Documentation: https://github.com/niemasd/ViralMSA

7. FastTree — The Tree Builder

What it does: Constructs phylogenetic trees from aligned sequences using maximum likelihood methods.

When to use it: - You have a multiple sequence alignment - You want to infer evolutionary relationships - Working with 50-10,000+ sequences

My use case: Built phylogenetic tree of 100 SARS-CoV-2 genomes to trace pandemic evolution and identify lineages.

What phylogenetic trees show: - Evolutionary relationships: Which sequences are most closely related - Divergence: Branch lengths show genetic distance - Common ancestors: Internal nodes represent ancestral sequences

Key parameters:

FastTree -nt -gtr -gamma \
  aligned_sequences.fasta \
  > phylogenetic_tree.nwk

Flags explained: - -nt = nucleotide sequences (use -lg for proteins) - -gtr = General Time Reversible model (standard for DNA) - -gamma = rate variation across sites (more realistic)

What I learned: - Model selection matters: GTR+Gamma is good default for DNA - Bootstrap values: Show confidence in tree topology (optional with -boot 1000) - Outgroup rooting: Include distantly related sequence (RaTG13) to root tree properly

Output format (Newick):

((Seq1:0.001,Seq2:0.002):0.005,Seq3:0.01);

Tree interpretation: - Numbers after colons = branch lengths (genetic distance) - Parentheses show groupings (clades)

Common mistakes: - Not using aligned sequences (FastTree needs aligned input!) - Wrong substitution model (DNA vs protein) - Not rooting tree (outgroup method is best)

Alternatives: RAxML (slower, more accurate), IQ-TREE (model selection), PhyML

Installation: conda install fasttree

Visualization: FigTree, Taxonium, or iTOL

8. LSD2 — The Molecular Clock

What it does: Estimates divergence times (dates) for phylogenetic trees using molecular clock methods.

When to use it: - You have a phylogenetic tree with known sample dates - You want to estimate when ancestors existed (tMRCA = time to most recent common ancestor) - Studying temporal evolution (pandemics, outbreaks)

My use case: Dated SARS-CoV-2 phylogenetic tree to estimate pandemic emergence: October–November 2019 (95% CI: September–December 2019).

How molecular clocks work: - Assumes ~constant mutation rate over time - Uses sample collection dates as calibration points - Estimates dates of internal nodes (ancestors)

Input files needed:

1. phylogenetic_tree.nwk (from FastTree)
2. dates.txt (sample collection dates)

Dates file format:

Wuhan-Hu-1  2019.96  # December 2019
USA-CA1     2020.00  # January 2020
Italy-123   2020.15  # February 2020

Key command:

lsd2 \
  -i phylogenetic_tree.nwk \
  -d dates.txt \
  -c \  # Use calendar dates
  -r a  # Estimate root position

What I learned: - Mutation rate: SARS-CoV-2 evolves at ~8.9 × 10⁻⁴ substitutions/site/year - R² value: Measures clock-like evolution (my result: 0.96 = excellent temporal signal) - Confidence intervals: Always report uncertainty (tMRCA: Oct–Nov 2019 ± 2 months)

Key results:

Mutation rate: 8.9e-04 subs/site/year
tMRCA: October–November 2019
R²: 0.96 (strong temporal signal)

This analysis: - Rejected "Italy June 2019" origin hypothesis - Supported Wuhan late-2019 emergence - Matched epidemiological data

Common mistakes: - Not having enough temporal signal (samples from narrow time range) - Wrong date format (use decimal years: 2020.5 = July 2020) - Not checking R² (< 0.8 = weak clock signal)

Installation: https://github.com/tothuhien/lsd2

Output: Dated tree in Nexus format

💊 PART 4: Functional Analysis

9. BioCyc / EcoCyc / MetaCyc — The Pathway Databases

What it does: Provides comprehensive metabolic pathway information for identifying enzyme functions and metabolic dependencies.

When to use it: - Identifying drug targets - Understanding metabolic requirements - Pathway reconstruction - Analyzing enzyme networks

My use case: Identified guanylate kinase as SARS-CoV-2 drug target through metabolic pathway analysis.

How I used it: 1. Query: "What nucleotides does SARS-CoV-2 need?" 2. Answer: Massive amounts of GTP for RNA synthesis (~30,000 nt × thousands of copies) 3. Analysis: Guanylate kinase catalyzes: ATP + GMP ↔ ADP + GDP 4. Insight: Virus needs high de novo GTP synthesis; human cells recycle from RNA pools 5. Target: Block guanylate kinase = starve virus, spare host cells

BioCyc databases: - EcoCyc: E. coli pathways (model organism) - MetaCyc: General metabolic pathways (all organisms) - BioCyc: Organism-specific databases (thousands of species)

Key concepts: - Reachability analysis: Can organism synthesize compound X from available nutrients? - Chokepoint reactions: Enzymes that are sole producers/consumers of metabolites - Dead-end metabolites: Compounds with only one reaction (potential drug targets)

What I learned: - Web-based: No installation needed (https://biocyc.org) - Pathway diagrams: Visual representation of enzyme networks - Substrate-product relationships: Trace metabolic flow - Literature integration: Links to papers validating predictions

Real discovery:

Target: Guanylate Kinase (EC 2.7.4.8)
Reaction: ATP + GMP → ADP + GDP
Rationale: SARS-CoV-2 requires high GTP synthesis
Validation: Renz et al., Cell Metabolism (2020)
Status: Experimentally validated drug target

This is the power of computational biology: Predict drug targets from metabolic analysis, validate experimentally.

Alternatives: KEGG, Reactome, Pathway Tools

Access: https://biocyc.org (free for academic use)

10. Primer3 — The Primer Designer

What it does: Designs PCR primers for amplification, sequencing, or diagnostic assays.

When to use it: - Need primers for specific gene/region - Designing diagnostic RT-PCR assays - Validating bioinformatic predictions experimentally

My use case: Designed RT-PCR primers targeting SARS-CoV-2 N gene for diagnostic detection.

Key parameters:

Product size: 75-150 bp (RT-PCR optimal)
Primer length: 18-25 bp
Tm: 58-62°C (annealing temperature)
GC%: 40-60%

What Primer3 checks: - No hairpins: Primers shouldn't fold on themselves - No self-dimers: Forward/reverse shouldn't bind each other - Specificity: Unique to target (verify with BLAST) - Tm matching: Forward and reverse Tm within 2°C

Workflow: 1. Get target sequence (from Prokka annotation) 2. Run Primer3 (web or command-line) 3. BLAST primers against human genome (check specificity) 4. Validate: No human hits = good primers

My primers:

N gene target (positions 28,000-28,500)
Forward: 5'-GGGGAACTTCTCCTGCTAGAAT-3' (Tm: 59.8°C)
Reverse: 5'-CAGACATTTTGCTCTCAAGCTG-3' (Tm: 60.1°C)
Product: 113 bp

BLAST result: 100% specific to SARS-CoV-2
             0 hits to human genome ✓
             0 hits to common respiratory pathogens ✓

What I learned: - Gene choice matters: N gene highly expressed, conserved across SARS-CoV-2 variants - Avoid repetitive regions: Primers in unique sequences only - Test in silico first: BLAST saves expensive wet-lab failures

Common mistakes: - Not checking specificity with BLAST - Designing primers across splice junctions (for eukaryotes) - Ignoring secondary structure

Web version: https://primer3.ut.ee

Installation: conda install primer3

🎨 PART 5: Visualization & Platforms

11. Taxonium — The Tree Visualizer

What it does: Interactive visualization of massive phylogenetic trees (millions of sequences).

When to use it: - Viewing large phylogenies - Exploring pandemic spread patterns - Interactive tree navigation

My use case: Visualized 100-sequence SARS-CoV-2 phylogeny with temporal metadata and variant annotations.

Features: - Zoom/pan: Navigate huge trees smoothly - Search: Find specific sequences instantly - Metadata: Color by date, location, variant - Time-scaled: X-axis = time (from LSD2 dating)

What I learned: - Web-based: No installation (https://taxonium.org) - Fast rendering: Handles millions of sequences - Publication-ready: Export high-res figures

Installation: Web-based (upload your tree)

12. Jalview — The Alignment Viewer

What it does: Visualizes and edits multiple sequence alignments.

When to use it: - Checking alignment quality - Identifying conserved residues - Annotating functional regions - Preparing publication figures

My use case: Visualized spike protein alignment to identify 6 key RBD mutations.

Features: - Color schemes: Highlight conservation, chemistry, mutations - Consensus sequence: See most common residue at each position - Manual editing: Fix alignment errors - Export: Publish-quality figures

Installation: https://www.jalview.org (Java application)

13. Galaxy — The Workflow Platform

What it does: Web-based platform for running bioinformatics tools without command-line skills.

When to use it: - Learning bioinformatics (beginner-friendly) - Running standard workflows - No access to computing cluster

Why I used Galaxy: - No installation: Everything browser-based - Point-and-click: Select tools, set parameters, execute - Workflows: Save and repeat multi-step analyses - Server resources: Uses their computing power (not your laptop)

Tools available: - SPAdes, QUAST, Prokka, BLAST, MUSCLE, FastTree, and 500+ more

What I learned: - Perfect for learning: See tool inputs/outputs clearly - History tracking: All analyses saved automatically - Sharable: Export workflows for reproducibility

Limitations: - Slower than command-line (web overhead) - Less control over advanced parameters - File size limits on public servers

Access: https://usegalaxy.org (free)

When to graduate to command-line: - Running hundreds of analyses - Need custom parameters - Building automated pipelines

🎯 Quick Reference: Which Tool When?

I have raw sequencing reads → Want: Genome - Use: SPAdes (assembly) - Then: QUAST (check quality)

I have a genome → Want: Gene locations - Use: Prokka (annotation) - Validate: BLAST top genes

I have sequences → Want: Find similar ones - Use: BLAST (homology search)

I have multiple sequences → Want: Compare them - Use: MUSCLE or ViralMSA (alignment) - View: Jalview

I have aligned sequences → Want: Evolutionary tree - Use: FastTree (phylogeny) - View: Taxonium

I have tree + dates → Want: Emergence time - Use: LSD2 (molecular clock)

I have annotated genes → Want: Drug targets - Use: BioCyc (pathway analysis)

I want PCR primers → Want: Validated primers - Use: Primer3 (design) - Then: BLAST (validate specificity)

I'm a beginner → Want: Try tools easily - Use: Galaxy (web platform)

💡 Lessons from the Trenches

Lesson 1: Don't Optimize Prematurely

Mistake: Spending hours tweaking SPAdes parameters before seeing results.
Fix: Run with defaults first. Only optimize if results are bad.

Lesson 2: Validate Everything

Mistake: Trusting Prokka gene predictions blindly.
Fix: BLAST important genes. Check against literature.

Lesson 3: Keep File Naming Consistent

Mistake: Files named output.fasta, output_2.fasta, final.fasta, final_FINAL.fasta
Fix: Use descriptive names: sarscov2_assembly_spades_k25.fasta

Lesson 4: Document Your Commands

Mistake: Running tools, getting results, forgetting exact parameters used.
Fix: Keep a notebook (physical or digital) with every command.

Lesson 5: Visualization Catches Errors

Mistake: Seeing good N50 number, not visualizing alignment.
Fix: Always visualize. Numbers lie; plots don't.

Lesson 6: Read the Manual (Really)

Mistake: Googling random tutorials instead of reading official docs.
Fix: Official documentation is better than blog posts (usually).

📚 Building Your Toolkit: Installation Guide

Beginner (No Command Line):

1. Start with Galaxy (https://usegalaxy.org)
2. All tools available through web interface
3. Perfect for learning workflow

Intermediate (Basic Terminal Skills):

Install via Conda (package manager):

# Install Miniconda first
conda create -n viral_genomics python=3.9
conda activate viral_genomics

# Install tools
conda install -c bioconda spades quast prokka blast muscle fasttree

Advanced (HPC/Cluster Access):

• Use environment modules: module load spades
• Build from source for latest versions
• Containerize with Docker/Singularity

🚀 Your First Analysis: Step-by-Step

Goal: Assemble and annotate a viral genome

Data: SARS-CoV-2 (SRR10971381)

Steps:

# 1. Assemble genome
spades.py -1 forward.fastq -2 reverse.fastq -o assembly/

# 2. Check quality
quast.py assembly/contigs.fasta -o quast_results/

# 3. Annotate genes
prokka --kingdom Viruses assembly/contigs.fasta --outdir annotation/

# 4. BLAST best contig
blastn -query assembly/contigs.fasta -db nt -max_target_seqs 5

# Done! You've assembled and annotated a genome.

Time required: 1-2 hours (mostly waiting for tools to run)

🎓 Tool Selection Cheat Sheet

🔮 What's Next: Expanding Your Toolkit

Once you've mastered these 13 core tools, level up with:

Variant Calling: - VCF tools: Identify SNPs and indels - SnpEff: Annotate variant effects

Structural Analysis: - AlphaFold: Protein structure prediction - PyMOL: Structure visualization

Metagenomics: - Kraken2: Taxonomic classification - MetaPhlAn: Microbial profiling

RNA-seq: - Salmon: Transcript quantification - DESeq2: Differential expression

Long-Read Sequencing: - Canu: Long-read assembly - Minimap2: Long-read alignment

💬 Final Thoughts: Tools Are Just Tools

After using 15+ bioinformatics tools for my SARS-CoV-2 project, here's what I learned:

The tools don't matter as much as: 1. Understanding the biology (What question am I asking?) 2. Knowing the workflow (Which tool outputs feed into which inputs?) 3. Validating results (Does this make biological sense?) 4. Reading documentation (How does this tool actually work?)

The best bioinformatician isn't the one who knows the most tools.

The best bioinformatician is the one who: - Knows which tool to use when - Can troubleshoot when tools fail - Validates results skeptically - Understands the biological context

This toolkit got me from raw sequencing reads to: - ✅ Complete viral genome (29,903 bp) - ✅ 11 annotated genes - ✅ Evolutionary origins (96.1% to RaTG13) - ✅ Pandemic timeline (Oct-Nov 2019) - ✅ Drug target discovery (guanylate kinase)

The same toolkit can take you there too.

Start with one tool. Master it. Add the next. Repeat.

Before you know it, you'll have a complete bioinformatics toolkit for viral genomics—just like I did.

Syed Muhammad Ali Shirazi is a bioinformatics researcher bridging wet-lab molecular biology and computational genomics. His work focuses on viral evolution, genome assembly, and drug target discovery.

Connect: GitHub | LinkedIn | Email

Read More in This Series: - From Wet Lab to Code: My Journey into Bioinformatics - Assembling a Pandemic: My First Genome Assembly - Finding Drug Targets in a Pandemic Virus (coming soon) - Tracing Origins: Phylogenetic Analysis of SARS-CoV-2 (coming soon)

Bookmark this guide! Return to it whenever you're wondering "Which tool do I use for this?"

Have questions about any of these tools? Stuck on a particular analysis? Drop a comment or reach out—I'm happy to help!