Tag: bioinformatics

A practical guide to obtaining your own genome sequence: what to order, what coverage and file formats to insist on, what it costs, and how to pull reference gene sequences from public databases.

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 step-by-step pipeline for turning bulk RNA-seq FASTQ files into a gene-level count matrix, differential expression results, and pathway scores, with the specific tools, flags, and QC thresholds we use.

A technically specific guide to choosing a whole-genome test: what files you should demand, what coverage and platform choices change, and how to analyze the data yourself.

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

A step-by-step guide to turning your own blood RNA-seq FASTQ files into a normalized expression matrix, cell-type estimates, and pathway scores you can track across timepoints.

A breakdown of WGS pricing by depth, platform, and deliverable, from $200 research-core genomes to $5,000 clinical reports, plus the downstream storage and compute costs nobody quotes.

A practical walkthrough for calling and filtering copy number variants from a 30x whole-genome CRAM, with the limits of what each caller can see.

A working pipeline that turns raw CNV calls from a personal genome into an annotated and prioritized table, with visual confirmation.

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

The public genome sites worth using, what each is good for, and how to go from a reference genome to a file that describes your own.

A practical guide to the three things people mean by genome mapping, the aligners and flags we would use on a personal whole-genome dataset, and what the compute costs.

A working pipeline for taking raw whole-genome sequencing output (FASTQ, CRAM, VCF) through quality control, annotation, and variant triage, with the specific tools, flags, and thresholds we would use and the failure modes to watch for.

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 indexing a human reference, running bwa mem on 30x whole-genome FASTQs, and producing a sorted CRAM for variant calling.

A practical guide to moving variants, intervals, and gene models between GRCh37, GRCh38, and T2T-CHM13 using chain-based liftover, Liftoff, and LiftOn, with checks that tell you when the result is wrong.

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 step-by-step bioinformatics workflow for taking bulk RNA sequencing FASTQs from your own blood sample through quantification, quality control, normalization, and interpretation, with the tools, flags, and failure modes named.

A technical guide to DNA methylation testing — arrays versus whole-genome bisulfite sequencing versus nanopore, what the raw files look like, how to process them, and how much of the signal is real.

A practical guide to the web servers and databases that hold up when you point them at your own genome, transcriptome, and proteomics data, and the steps you should run yourself instead.

A working pipeline for calling deletions, duplications, inversions, and insertions from your own short-read whole-genome sequencing data, including which callers to run, how to merge them, and how to judge whether a call is real.

A practical walkthrough of what a sequencing lab hands you, how to verify it before you trust it, and how to go from raw reads to an annotated variant table you can query yourself.

A practical guide to turning an RNA-seq counts matrix into a ranked pathway table, with fgsea and g:Profiler run correctly.

A working pipeline for taking personal bulk RNA-seq from FASTQ to quantified transcripts, quality-controlled expression matrices, and interpretable gene-level signals, with the commands and parameters we use.

A practical pipeline for taking personal bulk RNA-seq FASTQs through quality control, quantification, normalization, and interpretation, with the parameters and failure modes that matter when n=1.

A working guide to going from FASTQ files to a gene-level count matrix you trust: reference choice, STAR two-pass alignment, Salmon selective alignment, strandedness, and the QC numbers that tell you whether the run is usable.

A practical pipeline for taking your own whole-blood RNA-seq from FASTQ to a quantified, QC'd expression matrix you can track over time, with the parameters, checks, and failure modes that matter.

A file-by-file walkthrough of RNA-seq output: FASTQ, BAM, quant.sf, count matrices, and QC reports, plus the pipeline and the interpretation rules we would use on your own data.

A practical walkthrough of building a STAR index, running --quantMode GeneCounts, choosing the correct strand column in ReadsPerGene.out.tab, checking alignment quality, and converting raw counts to TPM.

A working guide to building a STAR index, running a two-pass spliced alignment of human RNA-seq, and reading the output files that tell you whether the run is any good.

A working guide to estimating immune and tissue cell-type proportions from your own bulk RNA-seq: getting the expression matrix into the right space, choosing a reference, running marker- and regression-based methods, and checking the output against a blood count.

A practical pipeline for turning vendor raw files from a plasma proteomics run into an FDR-controlled protein quantification matrix you can model, with the tools, flags, and failure modes named.

A specific, opinionated toolchain for a single person's whole-genome, RNA-seq, proteomics, and CGM data: the tools we would run, the flags that matter, and the failure modes that silently corrupt results.

A step-by-step guide to processing personal plasma proteomics data, from raw mass spectrometry files or affinity panel exports through quantification, quality control, normalization, and longitudinal modeling in R.

A practical walkthrough of working with raw sequencing reads: reading the format, checking quality, aligning to a reference, and knowing when the data is good enough to call variants.

A practical answer to RNA-seq depth: 30-40 million paired-end reads for whole-blood expression profiling, why the number moves with your question, and how to check that you got what you paid for.

A working guide to turning raw RNA sequencing reads from your own blood into quality-controlled gene and transcript quantifications, with the specific tools, flags, and reference files we would use, plus the failure modes that silently corrupt results.

A technical comparison of genotyping arrays, exome sequencing and whole-genome sequencing, with the quality metrics to demand from each.

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 practical guide to genome visualization tools for your own sequencing data, from IGV and the UCSC browser to igv.js, with the files each one needs.

A working guide to aligning and quantifying your own RNA-seq data: reference choice, STAR and Salmon parameters, strandedness, quality thresholds, and the failure modes that silently distort expression estimates.

A working guide to turning FASTQ files from your own blood RNA into gene-level expression estimates you can interpret, with the quantification commands, normalization choices, and the failure modes that make people over-read their data.

What home genome kits measure, which file formats to insist on, and which variant classes they miss.

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 pipeline for taking personal bulk RNA-seq from raw FASTQ files to quantified expression, quality checks, reference comparison, and longitudinal analysis, with the specific tools, flags, and failure modes.

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 genetic report is a short curated document about a handful of variants. The data underneath it is a CRAM and a VCF with about five million variants. Here is how to read both, and how to check the report yourself.

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.

Genome mapping means at least four different things: historical linkage maps, aligning your reads to a reference, optical genome mapping for structural variants, and the colloquial sense of getting your genome sequenced. Here is how to tell them apart, what each costs, and the pipeline we would run on your own data.

A working pipeline for going from a raw germline VCF to a short list of variants you can reason about: normalization, annotation, frequency and evidence filters, pharmacogenomic star alleles, and the failure modes that make most self-interpretation wrong.

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.

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 clinical whole-genome sequencing report is a short curated document about a handful of variants. The FASTQ, CRAM, and VCF behind it contain roughly four to five million. Here is what each one gives you and how to work with the data yourself.

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

A practical map of omics data types, the public databases worth querying, and how to structure your own multi-omics data so annotation queries return something useful.

Where polygenic tests come from, how to compute scores yourself from a VCF, and the failure modes that silently corrupt a score.

A practical pipeline for taking raw DNA data — array export, VCF, or CRAM — and turning it into something you can query, annotate, and trust, plus what the file cannot tell you.

A working guide to loading your own BAM/CRAM, VCF, and RNA-seq files into IGV and igv.js: reference builds, indexing, annotation tracks, batch screenshots, and the visual checks that catch bad variant calls.

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.

A genetic panel sequences a curated list of genes at high depth and reports variants in those genes only. Here is what that buys you, what it misses, what it costs, and how to decide between a panel and whole-genome sequencing.

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

A working guide to going from raw sequencing reads to an annotated, filtered variant list you can reason about: file formats, strand conventions, QC thresholds, annotation commands, and the failure modes that produce confident nonsense.

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.

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 whole-genome sequencing sample is usually 4–10 mL of EDTA blood or a saliva kit; what comes back is 80–120 Gbp of reads, a CRAM, and a VCF with roughly 4–5 million variants. Here is how to judge the sample, the files, and the costs.

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 step-by-step guide to going from FASTQ files to gene-level counts, cell-composition estimates, and longitudinal comparisons using your own transcriptome data.

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 working pipeline that classifies the variants in a personal VCF under ACMG/AMP rules, and why automated calls disagree with expert curation.

The reagent cost of a 30x human genome is now in the low hundreds of dollars, but the price you pay depends on coverage, data delivery, and whether the lab is CLIA-certified. Here is the full cost stack, including storage and compute.

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

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 SNP microarray genotypes a fixed panel of several hundred thousand predefined positions and, from probe intensities, infers copy number and runs of homozygosity. Here is the data it produces, the tools to process it, and the variant classes it cannot see.

What structural variants are, which callers to run on short-read and long-read whole-genome data, the flags that matter, and how to tell a real call from an alignment artifact.

A working guide to variant effect predictors: what they score, how to run VEP with the right plugins, and which scores to trust.

A working pipeline for searching the 4 to 5 million variants in your genome: annotate, filter to a few dozen candidates, then check each by hand.

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 that turns a personal whole-genome VCF into an annotated variant table you can query, using VEP, gnomAD and ClinVar.

A working list of the tools that matter for analyzing your own genome, transcriptome, proteome, and biomarker data, with formats, flags, and the failure modes that bite.

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.

What whole exome sequencing covers, where capture fails, and how to check the quality of an exome you already own.

A working pipeline from a counts matrix to a ranked, deduplicated pathway table for personal RNA-seq, including the n=1 designs that are valid, the blood cell composition problem, and which tools to trust.

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.

What whole-genome screening in a healthy adult finds, what it misses, which files and tools to use, and where the interpretation gets hard enough that you need a clinician.

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 practical walkthrough from FASTQ to gene-level counts, cell-composition estimates, and pathway scores, written for someone analyzing their own blood RNA-seq rather than a two-group experiment.

A technical comparison of array-based consumer DNA tests, consumer whole-genome sequencing, and clinician-ordered panels: file formats, error modes, prices, and what to do with the raw data.

A practical guide to designing, quantifying, and modeling a longitudinal RNA-seq series from one person — sampling schedule, salmon quantification, spline and impulse models, trajectory clustering, and the confounders that will ruin the result if you ignore them.

A technical review of consumer and clinical whole genome sequencing: coverage depth, file formats, variant calling limits, and what the data can and cannot tell you.

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.

"Genome manager" usually means a vendor's web portal for your sequencing results. Here is what that portal does, what it hides, and how to run your own catalog of VCFs, BAMs, expression matrices, and lab panels with tools you already know.

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.

How to download the raw genotype file, convert it to VCF against a reference, lift it to GRCh38, impute, score, and know which conclusions the array can and cannot support.

Most consumer wellness DNA tests report array genotypes and low-evidence trait associations. Here is what a genome can and cannot tell a healthy person, which file formats and tools matter, and where the real signal is.

A working guide to lifting positions, VCFs, intervals, and probe manifests between GRCh37, GRCh38, and T2T-CHM13, including which tool to use for each file type and how to tell when the lift silently went wrong.

A practical map of the software that turns raw multi-omics files into results you can query, with the commands, formats, and failure modes that matter for a single person's data.

A technical walkthrough of DNA methylation testing. Compares arrays, bisulfite sequencing and nanopore, then covers the IDAT pipeline and clocks.

Two very different assays are sold under the name 'methylation panel': a one-carbon biochemistry blood panel and a DNA methylation assay. Here is what each one measures, which files you get, and how to process them yourself.

A practical guide to correlating genes, samples, and timepoints in personal RNA-seq data: which transform to use before computing a coefficient, how to filter, how to handle confounders, and how to correlate expression against proteomics, labs, and continuous glucose data.

A concrete walkthrough of bulk RNA-seq: where to get a real example dataset, what the files contain, how to quantify with salmon, and how to get to a gene-level table you can interpret, including the case where you only have your own samples.

A practical pipeline for turning your own bulk RNA-seq FASTQs into quantified gene and transcript expression, with the tool choices, flags, QC thresholds, and failure modes that matter for a single-person longitudinal dataset.

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.

Three different things get called a DNA clock. This page covers the epigenetic age clock, which assay to run and how to compute the score yourself.

A practical walkthrough of going from FASTQ, BAM/CRAM, and VCF files to an actual nucleotide sequence you can read, translate, and check against the reads it came from.

A step-by-step guide to taking a protein abundance matrix, building a defensible ranking statistic, and running over-representation and rank-based enrichment in R, including how to read a negative enrichment score.

A comparison of the companies that will sequence or map your genome, what data each one hands back, and how to judge an offer by coverage, read length, and file deliverables rather than marketing copy.

What whole-genome sequencing results contain, which files matter, how to interpret a variant classification, and where the analysis stops and a clinician starts.

A working guide to building the handful of plots that matter for a personal molecular dataset: coverage tracks, variant pileups, copy-number profiles, expression MA and volcano plots, and a genome-wide circular summary. With real commands, file formats, and the failure modes that produce misleading pictures.

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 working guide to turning RNA-seq quantifications into an annotated, versioned gene table. Covers choosing an annotation, tx2gene and biotypes.

A working pipeline from FASTQ to a ranked pathway table in R. Covers salmon, DESeq2 and fgsea, plus the confounders behind most false pathway hits.

A genome kit is worth buying only if it ships you 30x PCR-free whole-genome sequencing and the underlying files. Here is the spec sheet, the QC commands to run on delivery, and what drugstore DNA kits measure.

There are two products sold as a 'methylation report': an MTHFR-style SNP panel from genotyping data, and a genome-wide DNA methylation array read out as epigenetic clocks. They measure different things, and only one of them is a measurement of your current biology.

Web platforms are good at the downstream half of RNA-seq (differential expression, enrichment, plots) and bad at the upstream half (FASTQ to counts). Here is the split we'd use, with the commands, parameters, and failure modes.

A concrete walkthrough of the RNA-seq workflow from FASTQ to interpreted results: quality control, pseudoalignment with salmon, count import with tximport, differential expression with DESeq2, and the sanity checks that catch most errors.

A practical guide to adapter, quality, poly-G and poly-A trimming for RNA-seq FASTQs: which tools to use, the exact flags, how much trimming is enough, and how to verify you did not damage the data.

A working pipeline for calling somatic SNVs and indels with GATK Mutect2, from BAM to annotated VCF. Covers results at low variant allele fraction.

A step-by-step guide to annotating a personal WGS VCF with Ensembl VEP. Covers cache setup, the plugin stack and consequence picking.

A working pipeline for going from RNA-seq FASTQs to junction counts, PSI values, and a shortlist of splice-altering variants from your own genome, with the tools and parameters we would use.

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.

Read depth in RNA-seq is the number of reads assigned to your sample and, per gene, the number of reads supporting each transcript. This page explains how to compute it from your own files, why 30x means nothing here, and what depth to ask for.

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 practical spec for buying whole-genome sequencing: coverage, library prep, file formats, the QC you should run yourself, and what WGS still misses.

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 to turning transcript quantifications into plots that tell you something: sample-level QC, longitudinal gene trajectories, differential expression views, and pathway summaries, with the R and command-line code to produce them.

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

A working guide to variant interpretation software: what each layer of the stack does, which tools we would use for a personal whole genome, and where the interpretation breaks.

A step-by-step guide to producing a volcano plot from a count matrix with DESeq2 and ggplot2, choosing thresholds that mean something, and reading the resulting shape correctly, including the single-cell and mass-spectrometry variants.

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 technical answer to which genetic sites are worth uploading raw DNA to, what the array file contains, and how to run the same analyses yourself with plink, bcftools, and an imputation server.

A map of the multi-omics vendor market in four layers, what files each layer hands back, and how to evaluate a provider if you want data you can analyze yourself.

A working guide to taking personal RNA-seq FASTQ files through quality control, quantification, sample sanity checks, and longitudinal within-person expression analysis, with the commands and the failure modes.

A palm-sized nanopore sequencer will sequence your DNA on your desk, but getting a usable human genome out of one takes several flow cells, a GPU, and a clear view of what long reads do well and badly. Here is the realistic path, with formats, inputs, and numbers.

The FASTQ layout, naming and read structure Cell Ranger expects. Covers producing the files from BCLs, verifying them and a run that finds nothing.

A consumer epigenetics kit measures DNA methylation at CpG sites on an array, then feeds those values into a regression model that outputs an age-like number. Here is what the assay does, what the error bars are, and how to work with the raw IDAT files yourself.

A line-by-line breakdown of exome sequencing prices in 2026: raw-data-only versus clinical CLIA reports, what drives the spread, and what the files look like when they land.

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 practical workflow for taking your RNA-seq FASTQ files to transcript quantification, then using web-based analysis tools for the parts they do well. Includes commands, parameters, cost estimates, and the failure modes that waste the most time.

A working pipeline for taking whole-blood RNA-seq FASTQ files to a gene-level count matrix, differential expression across timepoints, pathway scores, and cell-type composition, with the parameters and failure modes that matter.

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.

A practical walkthrough of differential expression analysis in R, from transcript quantification through DESeq2 and limma models, with the design decisions and failure modes that determine whether the gene list means anything.

A practical guide to ordering whole-genome sequencing for yourself: what coverage and read length to insist on, which files to demand, how to check quality yourself, and what the data can and cannot tell you.

A plain answer to what a genome is, what whole-genome sequencing produces, and how to work with your own FASTQ, CRAM, and VCF files without fooling yourself.

A concrete stack for working with personal genome, transcriptome, proteome, and biomarker data: file formats, tools, commands, and where each approach breaks down.

A step-by-step guide to quantifying, normalizing, modeling, and interpreting your own RNA-seq data in R, from FASTQ files through differential expression, pathway scoring, and blood cell deconvolution.

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.

Why arrays and consumer health reports fail on rare variants, what to demand from a sequencing provider, and how to run QC and annotation on your own genome.

Why genotyping arrays like 23andMe and AncestryDNA answer a narrow question, what whole-genome sequencing gives you instead, and how to work with the files yourself.

A technical comparison of consumer genotyping arrays, clinical panels, and whole-genome sequencing, including the raw file formats each returns and what you can do with them.

A working pipeline for analyzing your own DNA with open source tools, from array raw data to whole-genome FASTQ, including the annotation databases, the commands, and the failure modes that produce wrong answers.

You can run a nanopore sequencer on your kitchen table and get real reads, but you cannot get clinical-grade whole-genome coverage that way. Here is what home sequencing produces, what it costs, and where sending a sample out is the better call.

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.

What a WGS service delivers, what the files look like, what coverage and platform choices change, and how to tell a real provider from a reseller.

A working guide to running DESeq2 on bulk RNA-seq counts. Covers the count matrix, dispersion, shrinkage and the sanity checks that catch most mistakes.

A worked walkthrough of what real DNA results look like: array text files, VCF lines field by field, coverage and callability checks, annotation with VEP, and what a 'positive' result does and does not mean.

A step-by-step pipeline for small RNA sequencing data, from adapter chemistry and UMI handling through hierarchical annotation, isomiR-level quantification, and differential expression, with the biofluid-specific failure modes that break naive runs.

A breakdown of WES pricing: research-grade versus CLIA-clinical, what drives the per-sample cost, how trios are billed, and why the sequencing is the cheap part of the project.

A breakdown of consumer, research-core, and clinical whole genome sequencing prices, what each tier gets you in files and coverage, and where the hidden costs sit.

A working guide to diagnosing and handling batch effects in bulk RNA-seq, from design and TMM normalization through limma, ComBat-seq, and RUV, with the checks that tell you whether the correction helped.

Why the data structure chosen for a genome, a variant set, an expression matrix, or a phylogeny decides which questions can be asked and what runs in reasonable time, prompted by a Boundary talk on coding agents.

Genetic Genie's methylation panel reads about two dozen genotypes out of a consumer array file. This guide shows how to extract and verify those calls yourself, what they can and cannot tell you, and how to measure actual DNA methylation if that is what you were after.

How to run a genome-wide association study in R end to end, from VCF to QC to association testing to polygenic scores, and what you can and cannot do with a single genome.

A practical pipeline for turning a tellmeGen raw data export into a build-verified VCF, running quality control, annotating it, and understanding what a genotyping array can and cannot tell you.

A practical comparison of Oxford Nanopore, Illumina, Element, PacBio, and Sanger for sequencing one person's genome: why we would choose nanopore long reads, what to ask a provider for, and the pipeline we would run on the output.

A practical comparison of DNA methylation tests: which array, which clocks, how to get the raw IDATs, and how to process them yourself with sesame and dnaMethyAge. Plus the noise sources that make a single epigenetic age number close to meaningless.

A step-by-step method for pulling rs1801133 and rs1801131 out of a 23andMe, AncestryDNA, or WGS file yourself, getting the strand right, and understanding what the result does and does not tell you.

A working guide to interpreting raw genotype files from 23andMe or Ancestry, converting them to VCF, annotating variants, and knowing where array data stops being useful.

A technical account of whole genome sequencing as a data product: coverage and chemistry, file formats, a pipeline we would run, and the questions a genome can and cannot answer.

Master the mrna sequence to dna sequence conversion. Covers basic rules, strand orientation, reverse complements, and design considerations for researchers in

Master the codon bias table to improve protein expression. Learn to calculate RSCU and CAI metrics while avoiding common bioengineering pitfalls in 2026.

Master library preparation for next generation sequencing with our guide. Covers DNA/RNA workflows, QC, troubleshooting, and prep's computational impact.

Master RNA sequencing library preparation with our guide. Learn workflows, QC steps, and how prep choices impact analysis for optimal results.

Master protein domains and motifs. Discover their function, detection tools, and application in cell design and DNA engineering workflows.

A guide to the respiratory viral panel. Covers detection technology, assay design, validation and bioinformatics.

A whole exome sequencing review for R&D teams. Covers WES methodology, bioinformatics, limitations and data integration with models.

The definitive guide to the adaptor sequence illumina system. Find sequences, learn trimming with Cutadapt, and troubleshoot issues for clean NGS data.

Discover how genomic DNA libraries work. This guide covers construction, QC, analysis, and applications in genome sequencing and synthetic biology.

Curious what is whole exome sequencing? Explore how WES works, its role in research, and how to interpret the data in our clear, practical guide for 2026.