Forward Deployed Engineer

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.

Salary: 160K - 210K USD a year

Originally posted on Himalayas