Tag: variant-calling

A step-by-step pipeline that turns your own whole-genome data into a normalized and annotated variant set, with the tools and filters we would use.

A step-by-step guide to going from FASTQ or CRAM to a filtered, annotated germline VCF on one human genome using BWA-MEM2, GATK4 HaplotypeCaller, and hard filters, with the failure modes that matter at n=1.

A technical account of exome sequencing: capture chemistry, coverage statistics, and the failure modes that decide between WES and WGS.

A working pipeline for human exome data with BWA-MEM, GATK HaplotypeCaller and VEP, with the flags that matter and the failure modes.

A technical walkthrough of pharmacogenetic star-allele calling from whole-genome data: which genes have real evidence, why CYP2D6 breaks most pipelines, and how to read a diplotype-to-phenotype report without over-trusting it.

A step-by-step guide to processing your own whole-genome and RNA sequencing data, and to validating the pipeline against a truth set.

A step-by-step guide to turning raw FASTQ files from whole-genome and RNA sequencing into aligned, called, annotated, and validated results on your own hardware, with the specific tools, flags, and quality thresholds we use.

A working guide to the files a sequencer produces and what to do with them: FASTQ through alignment, variant calling, annotation, and RNA quantification, with the commands, parameters, and failure modes that matter.

A SNP is a single base position in the genome where people carry different letters. This is how those positions get called from sequencing data, filtered, annotated, and read without over-reading them.

A working guide to analyzing your own whole-genome sequence: the file formats, the pipeline we would run, and what the calls support.

A working guide to going from raw whole-genome reads to a filtered, annotated set of single-nucleotide variants you can query, including the tools, flags, quality checks, and the places this pipeline quietly fails.

A practical software stack that takes a personal 30x whole genome from FASTQ to annotated variants, with the failure modes that waste days.

A direct account of WGS applications, from rare-disease diagnosis to pharmacogenomics, plus the file formats, tools, and flags you need to analyze a 30x genome yourself.

What a genome analyzer is at the file level, from FASTQ to CRAM to VCF, and how to measure your own error floor against GIAB.

Array-based consumer kits genotype a few hundred thousand preselected sites accurately and everything else badly. If you want data you can analyze yourself, you want 30x whole-genome sequencing with FASTQ, BAM/CRAM, and gVCF returned.

A working pipeline for taking 30x PCR-free FASTQs to aligned CRAM, a filtered and annotated variant set, structural variants, and the QC numbers that tell you whether any of it is trustworthy.

A working pipeline that turns 30x whole-genome FASTQs into a filtered and benchmarked VCF, plus what changes when the variants are somatic.

A step-by-step WGS pipeline for a single human genome: alignment with bwa-mem2, variant calling with DeepVariant, structural variants with Manta, annotation with VEP, and the QC numbers that tell you whether any of it worked.

A whole genome is every base of your DNA, read at some depth, delivered as files. Here is what the files contain, which tools to run on them, and where short-read WGS quietly fails.

A practical pipeline for taking raw whole-genome sequencing data from FASTQ to annotated variants, structural variants, pharmacogenomic diplotypes, and polygenic scores, with the QC steps that decide whether any of it means anything.

What a personal genome service delivers, which file formats to insist on, and the limits of interpreting a genome in a healthy person.

A concrete stack for analyzing your own whole-genome data: alignment, variant calling, annotation, pharmacogenomics, and polygenic scores, with the flags, file sizes, and failure modes that matter.

A working pipeline for turning 30x whole-genome sequencing reads into an aligned, called, benchmarked, annotated and filtered variant set, plus the triage rules that keep the short list short.

Genotyping arrays, exomes, and whole genomes fail in different ways and in different places. Here is where the errors live, how to check your own data, and what accuracy numbers mean per-variant rather than per-test.

A working pipeline for taking raw whole-genome sequencing reads of your own DNA through alignment, variant calling, annotation, and a queryable table you can hand to an analysis agent.

Whole exome sequencing covers roughly 1-2% of the genome at high depth. What the files contain, which tools we use, and where the coverage gaps are.

A working pipeline from FASTQ to an annotated variant list, with the QC steps and the filters that make 4.5 million variants readable.

A genome reader is really three things: the sequencer that produces reads, the aligner and variant caller that turn reads into a genome, and the browser that lets you look at it. Here is what each step produces, which tools we would run, and where they fail.

A technical account of pharmacogenetic panels, whole-genome sequencing, and the files they produce: coverage requirements, star-allele calling, CYP2D6 copy number, and where prices land in 2026.

A working pipeline from FASTQ to annotated VCF for one human genome, with DeepVariant and GATK calling and benchmarking against GIAB truth sets.

A practical comparison of whole-genome and whole-exome sequencing, with the pipeline, tools, flags, and failure modes we would use to analyze either one.

A step-by-step guide from raw FASTQ to an annotated variant table on your own machine, covering alignment, calling, QC thresholds and annotation.

How to tell Ensembl the database from ensemble methods in bioinformatics, then use both on your own whole-genome VCF: offline VEP annotation, plugin scores, and consensus calling across pipelines.

A working GATK pipeline for calling SNPs and indels from RNA-seq reads, with filters suited to transcriptomic data and a check against genome calls.

How exome capture works, the analysis pipeline for your own FASTQs, and the failure modes that decide whether an exome is the right assay.

A step-by-step guide to taking raw whole-genome FASTQs through alignment, variant calling, validation, and annotation, with the specific tools, flags, and quality thresholds we use.

A working end-to-end path from raw FASTQ to an annotated, QC'd variant set using GATK, DeepVariant, and VEP, with the flags, file sizes, runtimes, and failure modes that matter.

A working pipeline for a personal whole genome: alignment, variant calling, annotation, and the QC steps that catch the errors most people miss. Tool names, flags, file formats, and failure modes.

A working pipeline for whole-exome data from FASTQ to VCF, with the filters that matter and the places where exome capture loses to a whole genome.

A practical guide to comparing whole genomes: your VCF against the reference, two callsets of the same sample, your genome against a relative's, and human against other species. Tools, flags, and the failure modes that produce fake differences.

A working pipeline that turns 30x whole-genome FASTQ or CRAM into a filtered and annotated variant call set, with the tools and checks we would use.

A working pipeline for analyzing the SNPs in your own whole-genome sequence: alignment, variant calling with DeepVariant, QC thresholds that catch real failures, annotation, and the queries worth running first.

A step-by-step guide to taking 30x WGS FASTQs from a vendor portal to an annotated, QC-checked variant call set using spot instances, bwa-mem2, DeepVariant, and Nextflow. Includes real costs, memory requirements, and the failure modes that waste a weekend.

A technical guide to getting your DNA sequenced without handing the data to a consumer platform: what each tier of testing can resolve, where the error rates live, and how to store and analyze the files yourself.

A step-by-step pipeline from raw FASTQ to a filtered, benchmarked VCF for a single human genome, with the tool choices, parameters, and quality checks we would use.

What array, exome, and whole-genome testing each measure, which files to insist on, and a concrete pipeline for calling and annotating your own variants.

A practical guide to DNA analysis tools: what works on a 23andMe-style genotype file, what requires FASTQ/BAM/VCF from whole-genome sequencing, and the commands we would run at each step.

A step-by-step guide to going from raw FASTQ files to an aligned CRAM, a benchmarked variant call set, an annotated shortlist, and an RNA-seq expression table, with the actual commands, parameters, and quality thresholds we use.

A practical comparison of DeepVariant, GATK HaplotypeCaller, bcftools mpileup, Strelka2, and Clair3 for calling SNPs from your own whole-genome data, with commands, benchmarks, and the failure modes that matter.

A working stack for analyzing your own whole-genome sequencing data: alignment with BWA-MEM2 or Dragen, variant calling with DeepVariant, annotation with VEP, and interpretation limits you should respect.

A working guide to comparing genomes — your own against the reference and against benchmark truth sets, assembly against assembly, and hundreds of bacterial genomes at once — with the tools, flags, and failure modes that matter.

A step-by-step guide from raw FASTQ to a filtered, benchmarked and annotated single-sample VCF. Covers the tools, flags and quality numbers.

Cloning tools like SnapGene and Geneious answer a different question than personal genome analysis. A concrete stack for going from FASTQ to annotated variants, with the tools, flags, file formats, and failure modes that matter.

A working guide to array genotyping versus whole-genome sequencing, the files you get, the tools to run on them, and the failure modes that make confident-looking results wrong.

A working guide to calling, normalizing, annotating, and querying SNPs from your own sequencing or array data, with the specific tools, flags, and failure modes that matter.

Whole exome sequencing reads the ~1-2% of your genome that codes for protein. What it finds, what it silently misses, and how to read the files yourself.

A working guide to verifying, converting and analyzing a personal 30x whole-genome file. Covers the reference build, CRAM to BAM and coverage QC.

Why array-based consumer kits cap out fast, what a 30x whole genome resolves and which files to request. Includes a pipeline for analyzing the data.

A working end-to-end guide to going from FASTQ to a filtered, benchmarked VCF on a personal 30x human genome, with the specific tools, flags, reference files, and failure modes we would use.

How to genotype ABO and RhD from whole-genome sequencing data, and where short reads fail. A genomic call is not a transfusion-grade answer.

A breakdown of the genomic testing market by category — clinical labs, direct-to-consumer arrays, research-grade sequencing providers, and tumor profiling — with the file formats, coverage depths, and failure modes that decide whether the data is useful to you.