Principal Signal Processing / Applied Math Engineer

About the Role

We’re building a co-timing engine: software that takes multiple measurement streams that are “the same up to delay (and sometimes gain),” estimates the relative timing drift on short windows, aligns them onto a shared timebase, cancels what is truly shared, and turns what survives into a geometry/medium observable.

This role is for someone who can live in the uncomfortable middle: rigorous enough to keep the math honest, pragmatic enough to ship diagnostics that prevent “it looked good yesterday” failures.

What You’ll Own

• The core delay-polynomial toolkit: design, implement, and validate “delay brick” compositions (polynomials in delay operators) used for alignment and cancellation across benches and domains.
• Co-timing estimation + tracking: build robust estimators for time-varying delays/drift (edge cases: low SNR, clock mismatch, nonstationary nuisance, partial coherence).
• Spectral estimation that doesn’t lie: implement and choose between FFT/STFT/Welch/multitaper and phase-based methods; quantify bias/variance tradeoffs; produce confidence measures.
• Window diagnostics (“is the window legal?”): develop tests that decide whether assumptions hold on a window (W): delay commutation validity, stationarity/coherence checks, leakage/aliasing warnings, and failure-mode labeling.
• Stability tests / guardrails: define and enforce criteria so the engine refuses to hallucinate a notch or “shared component” when conditions don’t hold.
• Bench-to-API translation: turn math into a clean, inspectable API: inputs/outputs, invariants, unit conventions (e.g., Ω = ωτ), reproducible evaluation, deterministic debug artifacts.
• Proof-minded engineering (as needed): create “machine-checkable” style specs (property tests, invariants, certificates) even if not formal methods end-to-end.

What You’ll Build

• A delay-polynomial evaluation engine (time-domain + frequency-domain evaluation) with reference implementations and golden tests.
• A window scoring system: a scalar trust score + structured reasons (e.g., “coherence collapse,” “leakage dominated,” “noncommuting residual rising,” “unstable notch”).
• A stability/failure-mode suite: synthetic datasets + real bench logs that reproduce common field failures and verify fixes.
• A diagnostic report generator: plots + structured text that a non-specialist can use to answer “can I trust this cancellation?”

Required Qualifications

• Deep experience in DSP / statistical signal processing (spectral estimation, coherence, cross-correlation/phase methods, leakage, windowing, bias/variance).
• Strong applied math instincts: linear systems, complex analysis comfort (phasors), numerical stability, and modeling discipline.
• Proven ability to ship production-grade algorithms: testability, instrumentation, performance profiling, and robust edge-case behavior.
• Fluency in at least one implementation stack: Python (NumPy/SciPy) and/or C++/Rust; real-time constraints are a plus.

Preferred Qualifications

• Experience with time synchronization, clock drift estimation, or sensor fusion (audio/RF/IMU networks).
• Familiarity with multitaper, subspace methods, parametric spectral estimation, or Bayesian approaches to delay tracking.
• Comfort designing contract-driven systems: assumptions, validity tests, graceful degradation.
• Prior work translating research ideas into reliable tools used by non-experts.

How We Evaluate Success (First 90 Days)

• You deliver a window validity + stability gating layer that materially reduces false “success” notches on adversarial datasets.
• You ship a delay/drift estimator that stays stable under realistic clock mismatch and nonstationarity, with clear confidence metrics.
• You produce a repeatable failure taxonomy (what breaks, how we detect it, what we do next) that becomes part of default reporting.

Title & Level

Principal Signal Processing / Applied Math Engineer (senior technical lead / architect). You’ll be a core owner of the algorithmic “truth layer” of the platform.