Senior Staff Machine Learning Software Engineer

We need to output HTML fragment with sections for headings: About the role (maybe Position Overview), Responsibilities, Qualifications, maybe Skills? The posting includes "Strongly Preferred" and "Nice to Have". Those could be part of Qualifications or separate sections like "Preferred Qualifications" and "Additional Qualifications". But we should only include sections when there is real specific content. The posting includes "Qualifications" section with bullet points (must have demonstrated leadership...). Also "Strongly Preferred" and "Nice to Have". We could combine them under Qualifications with sub-sections? But spec says use

for section headings (e.g. About the role, Responsibilities, Requirements, Qualifications, Skills, Benefits, Pay, Schedule). So we can have About the role (Position Overview), Responsibilities, Qualifications. Possibly also Skills? The posting includes "Strongly Preferred" and "Nice to Have" which could be considered Skills. But we could incorporate them into Qualifications as sub-bullets. However spec says use

• for any list of duties/requirements/benefits. So we can have a
  for Responsibilities, and a
  for Qualifications (including must have, strongly preferred, nice to have). We need to preserve all substantive information. Also include location, job type, salary range? Those are metadata; we should fold minor metadata into a short

  or drop it. The instruction: "Do NOT put Job ID / requisition numbers as headings — fold minor metadata into a short

  or drop it." So location, job type, salary range are metadata; we can include them in a short

  at top. Probably include a paragraph: "

  Location: San Diego, CA | Job Type: Full-Time | Salary Range: $202,000 – $215,000

  " That's acceptable. We must not include boilerplate like EEO etc. Remove that. We must not create Pay/Schedule/Benefits sections unless posting actually states them. It does state salary range, but we already included in metadata paragraph; we could also make a Pay section but spec says prefer few substantive sections over many thin ones. Since we already have salary in metadata, we can skip Pay section. Similarly no Benefits or Schedule. Thus output:

  Location: San Diego, CA | Job Type: Full-Time | Salary Range: $202,000 – $215,000

  About the role

  ... (Position Overview paragraph)

  Responsibilities

  • ...
  ...

  Qualifications

  • ...
  ...
  We need to preserve all substantive info from Position Overview, Responsibilities, Qualifications (including must have, strongly preferred, nice to have). Let's extract. Position Overview paragraph: "We are building a product where learned models and compute-heavy inference components have to run inside a tight local runtime budget. Research code is only the starting point. This role owns the path from a working prototype to production inference that is measured, packaged, tested, and ready for repeated use in the field. You will work closely with the people developing the underlying algorithms, but your ownership is different: production readiness, performance, reliability, and the engineering boundary between exploratory model work and shipped execution. The strongest fit is someone who can explain the bottleneck they found, the number they moved, the tradeoff they accepted, and the test that kept the fix from regressing. If your best work is making inference faster, smaller, more predictable, and easier to ship, this role is likely a good match." We'll put that in

  . Responsibilities list: bullet points: - Turning research prototypes into production inference components with explicit latency, throughput, memory, and accuracy budgets - Optimizing the execution path: tensor layout, host/device transfers, batching strategy, kernel launch overhead, mixed precision, quantization, and memory reuse - Writing or tuning Rust, C++, and CUDA where framework-level optimization is not enough, then validating the improvement with profiler output and release-facing tests - Building inference-adjacent evaluation machinery: calibration checks, confidence behavior, regression detection, dataset slices, and failure-mode reporting tied to product metrics - Maintaining the deployment contract: model artifacts, runtime integration, versioning, reproducibility, and performance gates that block unsafe changes - Algorithm research and novel model design live on a separate track. You will collaborate with that team, translate prototypes into production constraints, and surface shipping risks early when a design needs to change. That's 6 bullet points. Qualifications: Must have demonstrated leadership or ownership with 2 of the 5 areas referenced below successfully: List of 5 areas: 1. Shipped constrained inference. You have personally moved a model or learned component from prototype to deployed runtime with a real latency, throughput, memory, or power budget. You can name the target, the bottleneck, and the change that closed the gap. 2. Rust/C++ at shipping depth. You have written production code in Rust or modern C++ where correctness, latency, memory layout, and ownership boundaries mattered. You can reason about the runtime behavior of the code you ship, not just its API surface. 3. CUDA and accelerator-aware execution. You are comfortable below Python: custom CUDA extensions or kernels, host/device memory movement, launch overhead, profiler traces, and the practical tradeoffs between framework convenience and a purpose-built implementation. 4. Performance-native judgment. You reason in wall-clock time, memory movement, launch overhead, bandwidth, numerical precision, and error budgets without needing those constraints added late in review. 5. Production engineering discipline. You define typed interfaces, deterministic behavior, reproducible artifacts, meaningful tests, and clean handoffs with upstream research code. Then "Strongly Preferred" list: - Rust at shipping depth, especially FFI boundaries, pyo3 / maturin, async runtimes, or performance-sensitive service code - Inference on constrained local hardware, embedded systems, edge devices, or budget-bound accelerator deployments - Quantization, mixed precision, model compression, or kernel fusion that shipped beyond a benchmark notebook - Calibration or confidence estimation used on production outputs, with monitoring or regression checks attached - Public or shareable evidence of engineering quality: code, technical writing, postmortems, talks, or a concrete shipped system you can discuss - Comfort using AI-assisted development tools while still owning correctness, tests, and review quality Then "Nice to Have": - Real-time or near-real-time signal-processing systems - Products that combine learned models with deterministic numerical code - Rust- or C++-based inference or numerical pipelines, including custom FFI to CUDA, cuDNN, TensorRT, or similar accelerator libraries We need to include all these as list items under Qualifications. Could separate into subheadings? But spec only allows headings like About the role, Responsibilities, Requirements, Qualifications, Skills, Benefits, Pay, Schedule. Could we add a "Skills" section for Strongly Preferred and Nice to Have? Might be better to keep Qualifications as one section with all items, but that may be long but okay. We must not invent or summarize away detail. So we need to keep each bullet as is. Thus Qualifications

  will contain all items: the 5 must-have areas (each as a bullet), then the strongly preferred items (each bullet), then nice to have items (each bullet). That preserves all. We should not include the introductory sentence "PhD (6+ years), MS (10+ years) or BS/BA (12+ years) of experience in life sciences or technology." That's part of qualifications; we need to include that as a bullet or maybe as a preceding sentence. It's substantive. We'll include as a bullet: "PhD (6+ years), MS (10+ years) or BS/BA (12+ years) of experience in life sciences or technology." Also "Must have demonstrated leadership or ownership with 2 of the 5 areas referenced below successfully:" is a sentence introducing the list; we could keep that as a bullet or as preceding text. Better to include as a bullet? Might be awkward. Could include as a

  before the list. But spec says use

  for prose. So we can have a

  for that sentence, then

  for the 5 areas. Then another

  for "Strongly Preferred:" then

  for those items. Then another

  for "Nice to Have:" then

  . That would be multiple sections but still under Qualifications heading? Actually we could keep Qualifications heading and then have paragraphs and lists inside. That's acceptable: we can have

  Qualifications

  then

  ...

  ...

  ...

  ...
  etc. That preserves all. Thus final HTML:

  Location: San Diego, CA | Job Type: Full-Time | Salary Range: $202,000 – $215,000

  About the role

  We are building a product where learned models and compute-heavy inference components have to run inside a tight local runtime budget. Research code is only the starting point. This role owns the path from a working prototype to production inference that is measured, packaged, tested, and ready for repeated use in the field. You will work closely with the people developing the underlying algorithms, but your ownership is different: production readiness, performance, reliability, and the engineering boundary between exploratory model work and shipped execution. The strongest fit is someone who can explain the bottleneck they found, the number they moved, the tradeoff they accepted, and the test that kept the fix from regressing. If your best work is making inference faster, smaller, more predictable, and easier to ship, this role is likely a good match.

  Responsibilities

  • Turning research prototypes into production inference components with explicit latency, throughput, memory, and accuracy budgets
  • Optimizing the execution path: tensor layout, host/device transfers, batching strategy, kernel launch overhead, mixed precision, quantization, and memory reuse
  • Writing or tuning Rust, C++, and CUDA where framework-level optimization is not enough, then validating the improvement with profiler output and release-facing tests
  • Building inference-adjacent evaluation machinery: calibration checks, confidence behavior, regression detection, dataset slices, and failure-mode reporting tied to product metrics
  • Maintaining the deployment contract: model artifacts, runtime integration, versioning, reproducibility, and performance gates that block unsafe changes
  • Algorithm research and novel model design live on a separate track. You will collaborate with that team, translate prototypes into production constraints, and surface shipping risks early when a design needs to change.

  Qualifications

  PhD (6+ years), MS (10+ years) or BS/BA (12+ years) of experience in life sciences or technology.

  Must have demonstrated leadership or ownership with 2 of the 5 areas referenced below successfully:

  • Shipped constrained inference. You have personally moved a model or learned component from prototype to deployed runtime with a real latency, throughput, memory, or power budget. You can name the target, the bottleneck, and the change that closed the gap.
  • Rust/C++ at shipping depth. You have written production code in Rust or modern C++ where correctness, latency, memory layout, and ownership boundaries mattered. You can reason about the runtime behavior of the code you ship, not just its API surface.
  • CUDA and accelerator-aware execution. You are comfortable below Python: custom CUDA extensions or kernels, host/device memory movement, launch overhead, profiler traces, and the practical tradeoffs between framework convenience and a purpose-built implementation.
  • Performance-native judgment. You reason in wall-clock time, memory movement, launch overhead, bandwidth, numerical precision, and error budgets without needing those constraints added late in review.