About the Role

We're looking for a Staff Software Engineer who owns technical direction, thrives in ambiguity, and uses AI as a natural part of how they build software. You won't just write code — you'll make decisions that shape systems for years, mentor engineers across teams, and drive the engineering bar higher across the organization.

This team designs and operates large-scale systems that ingest, process, and enrich diverse content like filings, transcripts, news, research, and more. In this role, you will build and own backend services and high-throughput data pipelines that turn raw content into structured, searchable intelligence.

As a Staff Engineer, you'll operate at the intersection of technical depth and organizational influence — turning ambiguous business problems into executable technical strategies, and shipping them end-to-end.

What You'll Do

• Set technical direction for your area — make build-vs-buy decisions, define architecture, and own the technical roadmap alongside product leadership.
• Take ambiguous problems and make them concrete — scope work, identify risks, break down large initiatives into deliverable increments, and drive alignment across teams.
• Design and deliver production-grade systems — scalable pipelines, robust services, and high-performance solutions that serve real users at scale.
• Leverage AI tools as part of your workflow — you use AI-assisted development (Claude Code, Cursor, Copilot) to accelerate your work and have formed opinions on when it helps and when it gets in the way.
• Evaluate and integrate AI/ML capabilities into production systems when the problem calls for it — you don't need to be an ML researcher, but you're sharp enough to pick up LLMs, embeddings, or classification models and put them to work.
• Drive cross-team technical initiatives — influence engineers and teams you don't manage. Lead RFCs, drive architectural reviews, and build consensus on hard technical decisions.
• Own what you build — from requirements to release to production. You build it, you run it. You monitor SLOs/SLIs, troubleshoot production issues, and continuously improve reliability.
• Raise the engineering bar — through code reviews, mentorship, technical documentation, and by modeling the standards you expect from others.

Must Have

• Strong in Python (our primary backend language). Comfortable working across languages — you've shipped production code in at least two.
• Designed and owned production systems serving real users at scale — not just contributed to them, but made consequential architectural decisions and lived with the outcomes.
• Led cross-team technical initiatives without formal authority — driven migrations, platform changes, or architectural shifts that required aligning multiple teams.
• Strong system design instincts — you think in terms of failure modes, data flow, scalability, and operational cost. You design for the system you'll maintain, not just the one you'll ship.
• Deep DevOps and operational experience — Kubernetes, cloud infrastructure (AWS/Azure/GCP), CI/CD, observability. You don't throw code over the wall.
• Track record of mentoring engineers and raising team standards — through pairing, reviews, RFCs, and leading by example.

Good to Have

• Experience leading large-scale migrations or platform rewrites
• Hands-on experience with AI/ML in production — LLMs, BERT, NLP pipelines, or document understanding systems
• Contributed to or driven engineering-wide standards, practices, or tooling
• Experience with content processing, enrichment, or search systems at scale
• Familiarity with Java (parts of our stack)
• Experience with GitOps, ArgoCD, or Infrastructure as Code
• Active practitioner of AI-assisted development (AIDLC) — uses AI tools daily in their engineering workflow

How We'll Evaluate You

Our technical interview includes a hands-on session in a real development environment — not a whiteboard. You'll work on a realistic, messy codebase with AI tools pre-configured and available. We're evaluating how you think, how you use tools, and how you approach problems — not whether you've memorized algorithms.

What we look for:

• How you navigate and make sense of unfamiliar code
• How you leverage AI tools — critically, not blindly
• How you decompose problems and make incremental progress
• How you communicate trade-offs and decisions as you work