R/reports/ml

This market splits into two distinct hiring tracks that barely overlap, and you must pick a lane before optimizing a resume. The larger, higher-paying track is frontier LLM work — post-training (RLHF, RLVR, DPO, SFT), distributed training infrastructure, and model evaluation — concentrated at Anthropic, Cohere, Cursor, Deepgram, OpenAI, Crusoe, and Databricks, with comp running $200K–$850K. The second track is applied/product ML and analytics — ranking, recsys, ads bidding, credit/fraud risk, and product data science — at Faire, Discord, Plaid, Semgrep, Abnormal, and Mercury, running roughly $150K–$270K. The same words ("ML", "Python") appear in both, but the actual skills and the people who get hired are different.

Where demand concentrates: three clusters dominate. (1) RL/post-training for LLMs shows up at Cursor, Cohere (multiple), Anthropic, Decagon, Crusoe, and Deepgram — this is the single hottest skill and the hardest to fake. (2) LLM evaluation as a first-class discipline (building benchmarks, LLM judges, eval infra) is its own job family now at Cohere and Anthropic — historically rare, currently under-supplied, high leverage. (3) Distributed training systems (FSDP/DeepSpeed/Megatron, multi-node GPU orchestration, checkpointing, InfiniBand/NCCL) gate the infra roles at Databricks, Cursor, Deepgram, OpenAI, and Applied Intuition.

What to prioritize: Python is non-negotiable everywhere (Anthropic literally interviews only in Python). PyTorch is the default framework; TensorFlow is fading to legacy mentions. If you target frontier labs, the fastest qualifying cluster is RL + distributed training + evaluation — these three transfer across nearly every lab posting here. If you target product ML, the cluster is SQL + experimentation/causal inference + ranking/recsys, which covers Faire, Discord, Plaid, and the DS roles.

What to skip: chasing breadth across every tool. The postings reward depth in one cluster plus credible production deployment ("prototype → production" appears verbatim repeatedly). Generic "data scientist who builds dashboards" positioning is the weakest signal in this set — even the analytics roles now demand experimentation rigor and production pipelines.

Stage signal: frontier labs (Anthropic, OpenAI, Cohere, Cursor) reward publications and "research → production" track records; growth/product companies (Faire, Discord, Plaid, Mercury) reward measurable business impact and shipping. Calibrate which story you tell.

Must have

• Python, SQL
• PyTorch, TensorFlow
• Kubernetes, Docker, Ray
• distributed training (FSDP, DeepSpeed, Megatron), CUDA/NVIDIA GPUs, NVLink, InfiniBand, RoCE
• Airflow, dbt, Snowflake, Spark
• Tableau, Looker, Power BI (for DS/analytics track)
• Git, cloud (AWS, GCP, Azure)

Nice to have

• Rust, Go, C/C++, TypeScript, JAX, Kotlin
• vLLM, TensorRT, ONNX Runtime, TFLite, NVIDIA Triton, TorchServe
• Qualcomm SNPE/QNN, MediaTek NeuroPilot (edge); Blackwell/Hopper-class GPUs
• Slurm, Prefect, Flyte, Dagster
• MLflow, Weights & Biases, Kubeflow
• XGBoost, scikit-learn, pandas, NumPy
• FastAPI/Flask, Redis, DynamoDB, Kafka/Kinesis/Redpanda
• FiveTran, Metabase, Retool, SageMaker, BigQuery
• Gradio, React/Svelte (OSS tooling); R (T&S analytics)

LLM post-training and RL

• RL for LLMs - RLHF, RLVR (verifiable rewards), DPO/preference optimization, policy optimization, reward modeling, reward/grader training for non-verifiable tasks; long-horizon credit assignment, training with less compute.
• Post-training stack - SFT, continued pretraining (CPT), PEFT/LoRA/adapters, SFT trajectory construction, Constitutional AI; building reproducible fine-tuning pipelines.
• LLM internals - transformer architectures (auto-regressive, seq2seq, causal LMs), attention variants, SSMs/Mamba, tokenization, KV cache; scaling laws and data-optimal regimes.

Evaluation and safety

• LLM evaluation - benchmark/dataset/environment design, LLM-as-judge training, eval efficiency, calibration, recall on rare cases; aligning metrics with the capability you actually care about.
• Hallucination and honesty - factual grounding, RAG for verification, confidence/uncertainty calibration, hallucination classifiers, miscalibration detection.
• Robustness and oversight - adversarial training, red-teaming pipelines, scalable oversight, misuse/misalignment detection, fairness/bias measurement.
• Experimental rigor - controlled ablations, isolating component impact, stress tests / OOD challenge sets, multi-metric evaluation (perplexity, FID, MUSHRA, recall@k).

Distributed training and systems

• Large-scale training - data/tensor/pipeline/sequence parallelism, multi-node orchestration, checkpoint/restore for week-long jobs, fault detection and automatic recovery.
• GPU performance - model FLOPs utilization, collective communication (NCCL), interconnect bottlenecks (NVLink/InfiniBand/RoCE), memory hierarchies, throughput/cost-per-run optimization.
• Inference and serving - low-latency real-time inference, continuous/streaming inference, model FLOPs utilization, profiling memory/speed across model and network layers.

Edge and model optimization

• Model compression - quantization (incl. mixed-precision and custom schemes), pruning, knowledge distillation, neural architecture search for edge targets.
• Hardware-aware deployment - CPU/GPU/NPU architecture, power/memory constraints, secure boot, encrypted model storage, OTA updates, on-device/air-gapped inference.
• Neural audio / codecs - low-bitrate neural codecs, residual/finite scalar quantization (VQ-VAE/FSQ), latent factorization, real-time DSP and streaming.

Applied ML: ranking, recsys, ads

• Search and ranking - query understanding, learning-to-rank, embedding models, transformer-based sequential modeling, graph neural networks, retrieval + personalization.
• Ads/marketplace ML - auction design, bid shading/multipliers, pacing, budget allocation, ROAS optimization, delivery ranking, identity graphs, privacy-compliant user modeling.
• Recommender systems - candidate retrieval, ranking, real-time inference, A/B testing, feature engineering on imbalanced data.

Data science and causal analysis

• Experimentation - A/B test design/analysis/interpretation at scale, causal inference, north-star metric design, champion/challenger and canary routing.
• Forecasting and statistics - time series modeling, Monte Carlo simulation, predictive analytics, multivariate regression, prevalence/sampling estimation, active learning.
• Credit and risk - underwriting model development, credit policy, cash-flow signals, LTV, fraud/anomaly detection, drift monitoring.

Agents and autonomy

• Agent systems - tool calling, orchestration, memory, long-context tracking, instruction following, long-horizon task completion under uncertainty.
• Robotics/AV learning - end-to-end driving models, imitation learning, world models, multi-sensor fusion (camera/LiDAR/radar), motion/behavior planning, diffusion-based planners.

Data and MLOps

• Production ML lifecycle - model registry/versioning, CI/CD for models, shadow/staged rollouts, lineage, retraining triggers, SHAP/explainability outputs.
• Data pipelines at scale - medallion (silver/gold) lakehouse modeling, unstructured audio/text data engineering, synthetic data generation, dataset curation/filtering for quality and diversity.

The 20% that covers 80%: Python + PyTorch + distributed training + RL/post-training + evaluation
For the frontier-lab track these five appear in nearly every posting and unlock Anthropic, Cohere, Cursor, OpenAI, Deepgram, Crusoe, and Databricks. Learn these before anything exotic.

• RLHF/RLVR/DPO end-to-end on a real model
• multi-node distributed training with checkpointing/recovery
• building an eval harness with an LLM judge

The product-ML equivalent cluster: SQL + experimentation/causal inference + ranking/recsys
This single cluster covers Faire (3 roles), Discord (2), Plaid (3), Semgrep, and the Cursor DS roles. It is a faster path to "qualified" than frontier work and far less crowded at the senior level.

• A/B testing and causal inference at scale
• learning-to-rank or recsys shipped to production with measured lift

Go deep here, broad-aware there
Go deep on one of: RL/post-training, evaluation, or distributed training systems — these are the gated, high-signal skills. Broad awareness is enough for serving frameworks (vLLM/TensorRT/Triton are interchangeable — learn one), orchestration (K8s/Slurm/Ray), and BI tools (Tableau/Looker/Metabase are interchangeable).

Table-stakes vs. genuine differentiators
Table-stakes everywhere: Python, PyTorch, "prototype → production", strong SWE fundamentals, A/B testing for product roles.
Genuine differentiators (frequently required, rarely held):

• distributed/large-scale RL specifically (not just RL theory)
• building evaluation benchmarks and LLM judges from scratch
• edge model optimization (quantization/distillation hitting hard latency/power targets)
• GPU performance engineering (MFU, NCCL, interconnect bottlenecks)

What's rising vs. fading
Rising: RLVR/verifiable rewards, LLM-as-judge evaluation, agentic/long-horizon tasks, edge+defense deployment, synthetic data pipelines. Fading: TensorFlow (now legacy mentions), pure dashboard-only data science, "use the API" applied roles — every applied posting now wants training/customization, not just prompting.

Unique to this domain vs. transferable
Unique: neural audio codecs (Deepgram), AV end-to-end learning (Nuro), trust-and-safety prevalence measurement (OpenAI). Highly transferable across most postings: distributed training, evaluation, RL post-training, and data pipelines — one investment in these unlocks labs, infra, and applied-research roles simultaneously.

Company-stage signals

• Frontier labs (Anthropic, OpenAI, Cohere, Cursor): publications at NeurIPS/ICML/ICLR, "research → production", high autonomy on ambiguous problems.
• Infra-heavy unicorns (Databricks, Crusoe, Applied Intuition): scale numbers (thousands of GPUs, multi-node), SLAs/SLOs, reliability.
• Growth/product (Faire, Discord, Plaid, Mercury): measurable business impact, north-star metrics, shipping cadence.

Lead with a production training or eval system you owned end-to-end
The phrase "prototype → reliable, measurable production impact" recurs across Decagon, Cohere, Cursor, and Anthropic. The single strongest line is a model/system you took from research to production with a number attached.

• "Built distributed RLHF pipeline (PyTorch + Ray, 64 GPUs) that improved task success +X% and shipped to production"
• "Designed eval benchmark + LLM judge adopted across N teams to gate model releases"

The combo that's an immediate yes: RL post-training + distributed training + a shipped capability gain
This trifecta directly matches Cursor, Cohere, and Anthropic post-training roles, which are the highest-comp postings here. Showing all three says you can do the work, not just describe it.

The "wow, that's deep" combo: model optimization hitting a hard physical constraint
Deepgram's edge role explicitly hopes for someone who makes "a 300M-parameter model run on 4GB of RAM and still hit accuracy targets." A line showing quantization/distillation against measured latency, memory, and power is rare and memorable.

• "Quantized + distilled STT model to run real-time on NPU at 4GB RAM, <X ms latency, within Y% WER"

Concrete projects eng managers are hoping to find

• Eval harness: a benchmark + LLM-judge system that catches regressions → "Built reproducible eval framework measuring agent reliability across N coding tasks; reduced shipped regressions by X%" (Cohere, Anthropic, Cursor).
• Distributed training resilience: checkpoint/restore for multi-day jobs → "Implemented fault detection + auto-recovery for 1000-GPU training, cutting lost compute by X%" (Databricks, OpenAI).
• Ads/ranking lift: auction or ranking model with revenue impact → "Shipped bid-shading model improving advertiser ROAS X% while protecting marketplace health" (Faire, Discord).
• Risk model in production: "Deployed cash-flow underwriting model with drift monitoring; improved approval rate X% at constant loss" (Plaid, Mercury, Abnormal).

Senior vs. junior framing of the same work

• Junior reads as task execution: "Trained a model using PyTorch and improved accuracy."
• Senior reads as system ownership and judgment: "Owned the post-training stack end-to-end; chose DPO over PPO after ablations, scaled to multi-node, and shipped to production serving M requests/day." The senior bar here (these are staff/principal roles) requires setting technical direction, ablation-driven decisions, and scale/ownership language.

Red flags that make recruiters pass

• Tool-listing without outcomes: "Familiar with PyTorch, TensorFlow, Keras, scikit-learn, Pandas, NumPy…" — reads as shallow.
• API-only AI work: "Built a chatbot using the OpenAI API" — every applied role here wants training/customization, not prompting.
• Dashboards as the headline for a DS role: "Created Tableau dashboards for stakeholders" with no experimentation or production pipeline.
• Generic soft-skill filler ("passionate, fast-paced, team player") with no technical anchor.

Match the dialect to the company
Frontier labs want publications, "truth-seeking", and research judgment; infra roles want scale numbers and reliability metrics; product companies want business impact and OKRs. The same project should be re-framed per target — lead with the axis that company rewards.