Forward Deployed Engineer

Earthly Technologies Inc.; San Francisco (CA); On-site; USD 160,000 - 210,000; Full time

Benefits offered by this job

Healthcare (US & Canada)

Equity / stock plan

Fully remote

Job summary

Earthly Lunar is a guardrails engine for the AI era, deployed with engineering teams to enforce standards across code, CI/CD, and deployments. You will be a hands-on engineer who evaluates and adopts Lunar, guiding deployments and turning real-world standards into automated guardrails.

This role requires production code work, collaboration with platform teams, and a focus on delivering guarded outcomes at scale.

Qualifications

• AI-native work style: majority AI-assisted; you build AI workflows and push frontier of engineering with AI agents.
• Customer-facing: you genuinely love customers and are credible in senior-level discussions.
• Builder and ops: you write production code and are comfortable in platform/infra.
• Platform/SRE/DevOps chops: expert with Dockerfiles, Kubernetes, and multiple CI/CD systems.
• Mid-level with strong growth aptitude: quickly learn, take initiative, and own outcomes.
• High ownership: comfortable navigating ambiguity and owning outcomes without direction.

Responsibilities

• Own each account's technical track from pre-sale evaluation to live guardrails and expansion.
• Be the technical partner in the sale: scope fit, prove value on real stack, answer tough questions.
• Guide install: stand up self-hosted Lunar Hub, Helm/Kubernetes, Postgres, S3, GitHub App, CI agent, Grafana.
• Turn standards into guardrails: write collectors and policies that enforce customer rules across repos.
• Write production code daily: Bash, Python, SQL for data gathering and posture normalization.
• Contribute to lunar-lib by generalizing customer work for broader use.
• Own the fix: diagnose and resolve deployment issues with customer team watching.
• Maintain long-term relationships with platform/engineering leaders to ensure ongoing success.

Skills

AI-native

Customer focused

Builder & ops

Platform/SRE/DevOps

Kubernetes

Dockerfiles

CI/CD

Ownership

Job description

Embed with the platform and engineering teams who adopt Earthly Lunar, get them live in production, and turn their hardest standards into enforced guardrails — writing real code the whole way.

About Earthly Lunar

Earthly Lunar is a guardrails engine for the AI era. As engineering organizations scale — and AI accelerates how much code they ship — leaders lose the ability to hold every team to their standards for quality, security, and compliance. Lunar turns those standards into automated guardrails enforced across the whole software development lifecycle — as code is written, on every pull request, and at deploy — consistently across every repo and team. Engineering leaders get back control and real-time visibility, and compliance evidence becomes a byproduct of enforcement. Whether code comes from a developer or an AI agent, Lunar makes sure it ships right.

We're an AI-native team backed by Innovation Endeavors and Work-Bench — with angels including Jeff Dean (Google's Chief Scientist), the CEOs of Datadog and Cockroach Labs, the founder of Sentry, and the creators of Elixir, Pandas, and Ruff/uv. We're trusted by enterprise teams across defense and large-scale SaaS, and growing fast.

The role

You're a hard-core engineer who happens to love working with customers. You'll work with the platform and engineering teams evaluating and adopting Lunar — before and after the sale — and own their success end to end: prove the fit, guide the deployment into their environment, then build alongside them to turn their real-world standards into automated, enforced guardrails. You own technical delivery for each account, from first call to guardrails running in production.

Lunar is a deeply technical product. Getting it deployed means Kubernetes, Helm, CI/CD, and a GitHub App; getting value from it means writing collectors and policies — small programs (Bash/Python) that gather signals from across a customer's SDLC (Dockerfiles, K8s manifests, Terraform, SBOMs, CI runs, VCS and vendor APIs) and evaluate them against the customer's standards. That's the same work our library, lunar-lib, is built from — and you'll own and extend it. The patterns you build in the field flow back into the product, so every customer benefits from the last.

This is a hands‑on engineering role: you write and own production code, and success looks like a customer's custom guardrails live and enforcing across thousands of engineers within ~90 days.

What you'll do

• Own each account's technical track end to end. From the technical evaluation before the deal closes, through install and first guardrails live, to expansion and long-term success — the whole arc is yours.
• Be the technical partner in the sale. Be the credible engineer in the room before the deal closes — scope the fit, prove the value on the customer's real stack, and field the hardest technical questions.
• Guide the install, hands‑on. Stand up the self‑hosted Lunar Hub with the customer's team — Helm chart on Kubernetes, Postgres, S3, the GitHub App, the CI agent, and Grafana dashboards — and debug it live when their environment throws you a curveball.
• Turn standards into guardrails. Sit with a platform team, understand a real requirement — a post‑incident action item, a compliance rule, an org convention — and write the collector and policy that enforces it across all their repos and pipelines.
• Write production code daily. Bash, Python, SQL — parsing Dockerfiles and K8s manifests, wiring up GitHub/GitLab and vendor APIs, normalizing messy signals into clean posture data.
• Feed the product. Generalize what you build with customers into lunar-lib so it ships to everyone.
• Own the fix. When a deployment breaks, you diagnose and resolve it yourself rather than filing a ticket — often with the customer's team watching.
• Own the relationship for the long haul. Earn the trust of platform and engineering leaders and the ICs on their teams, keep them successful and expanding long after go‑live, and translate between their world and ours.
• Build with AI, and build the AI story. Use Claude Code, Codex or any other AI tools extensively. Unlimited tokens available.

What we're looking for

These are the must‑haves. The first three are non‑negotiable.

• MUST: AI‑native to the core. The majority of your work is AI‑assisted. You build with Claude Code / agents every day, you build your own AI workflows, and you're pushing the frontier of how one engineer does the work of a team. If you're not already living this way, this isn't the role for you.
• MUST: You genuinely love customers. You’d rather be in the room untangling a customer's gnarliest deployment than heads‑down in isolation. You're calm and credible in front of platform and engineering leaders, and you get energy from making them successful.
• MUST: Both a builder AND an ops person. You write real production code and you're at home in the platform/infra world. Ops alone isn't enough — we need you fluent writing code. Dev alone isn't enough — we need real ops instincts. You have to be both.
• Real platform / SRE / DevOps chops. Expert with Dockerfiles. Comfortable enough with Kubernetes to guide a live Helm‑chart install and debug it. Fluent across multiple CI/CD systems (GitHub Actions, GitLab CI, Buildkite, CircleCI, Jenkins, and friends).
• Mid‑level, with a strong aptitude for growth. We weight the ability to learn quickly and take initiative over a complete match against every requirement listed here. A solid platform background that's less developed in some areas is fine, provided you are deeply curious to learn fast.
• High ownership. You navigate ambiguity, set your own path, and own outcomes without waiting to be told how.
• Backgrounds we love: ex‑founders (a failed startup is a plus, not a red flag), technical ex‑consultants, and early stage engineers who've shipped B2B products hand‑in‑hand with customers.

Nice to have

Bring any of these and we'll be glad. Nobody has all of them.

• Languages: Bash, Python, Go, SQL, TypeScript/Node, Earthfiles.
• Kubernetes & delivery: authoring Helm charts (not just installing them), ArgoCD, k8s RBAC / NetworkPolicies / ingress.
• Infrastructure as code: Terraform, CloudFormation, Pulumi (and comfort reading HCL).
• Observability: Grafana, OpenTelemetry / OTLP, Prometheus, Datadog.
• APIs everywhere: GitHub / GitLab APIs, and wiring up the APIs of dev‑infra and production‑infra tools in general (PagerDuty, Jira/Linear, container registries, cloud providers).
• Supply chain & code analysis: SBOMs (Syft, Trivy, cdxgen), SCA/SAST (Snyk, Semgrep, Gitleaks), signing & provenance (cosign, SLSA), OPA/Rego, ast‑grep / tree‑sitter.
• AI‑native building: MCP servers, agent skills and sub‑agents, editor/agent hooks (Claude Code, Cursor, Codex).
• Config wrangling: parsing YAML, HCL, JSON, Dockerfiles, CODEOWNERS into clean structured data.
• Startup DNA: startup experience; a failed‑founder background is a big bonus; a desire to start your own thing one day is very welcome.
• Product sense: B2B product‑building experience, working directly with the customer.
• Regulated / defense context: familiarity with SOC 2, NIST SSDF, FedRAMP, CMMC, or PCI DSS (some of our customers are in defense and finance).
• The adjacent space: developer portals / internal platforms (Backstage, Cortex, OpsLevel).

You might not be a fit if

• You'd rather stay heads‑down and away from customers.
• You want a pure sales‑engineering or solutions‑architect role and don't really want to write production code — there's plenty of customer‑facing work here, but the core bar is that you can build.
• You're an infra operator who doesn't want to write code — or a developer who doesn't want to touch infra.
• You need every requirement fully spec'd before you start; this role is high‑ambiguity by design.

How we work

• Small, senior, AI‑native team. Heavy AI leverage, high autonomy, fast loops.
• Your field work becomes the product. What you build with customers lands in lunar-lib and ships to everyone.
• Top‑down go‑to‑market. We win platform and engineering leaders; you help win them over technically, then make them wildly successful.
• Direct line to the founder/CEO and outsized ownership of how Lunar lands in the real world.

Compensation & logistics

• Base salary: $160,000–$210,000 (US base), depending on experience — plus equity.
• Location: Remote (US & Canada).
• Travel: Occasional — customer onsites and team gatherings, at most one trip per quarter.
• Type: Full‑time.

Benefits

• Healthcare, dental, and vision — including dependents (US & Canada)
• Incentive stock plan
• 401(k) / RRSP with employer matching (US & Canada)
• Life insurance (US & Canada)
• Credits for gym or activity equipment (US & Canada)
• Fully remote, with everyone within ±3 hours of each other — no late‑night meetings
• An early‑stage environment where your work has outsized impact and you operate with real freedom — excellent preparation if you want to take the founder path someday

The salary range above is the US base salary for this full‑time position. It does not include equity, bonuses, or other benefits. Ranges are determined by role, level, and location; within the range, individual pay reflects job‑related skills, experience, and training. We expect to hire near the middle of the range, and would pay near the top only in rare cases where a candidate's experience far exceeds what the role requires. Your hiring contact can share specifics for your location during the process.