Forward Deployed Engineer (FDE)

A Forward Deployed Engineer is the

sharp end of Innover's delivery. You embed directly with an enterprise client,

sit close to their product and technology leadership, and turn ambiguous

business problems into working, production-grade software fast. You own

outcomes rather than tickets: architecture through build, test, deployment, and

production support.

What sets this role apart is how

you build. Our FDEs are fluent, daily practitioners of AI-native engineering -

using agentic coding tools and disciplined guardrails to compress delivery

timelines without sacrificing quality. You are the forward point that connects

the client to Innover's broader delivery pods, translating in both directions

so the right thing gets built and shipped.

What you'll do

• Embed

with the client. Work

alongside the client's engineering, product, and executive teams; understand

their domain, their systems, and their constraints; and become a trusted

technical partner.

• Own

the full lifecycle. Take

features from architecture and design through implementation, testing,

deployment, and production support - shipping into the client's environment.

• Build

AI-native. Use

Claude Code, Cursor, and agentic workflows as core tools in daily development;

design the conventions and guardrails that keep an AI-augmented codebase fast,

maintainable, and safe.

• Translate

business into software. Convert

business requirements into technical solutions, scope and de-risk delivery

under ambiguity, and communicate progress, risk, and tradeoffs to non-technical

and executive stakeholders.

• Set

the standard. Define

architecture patterns and code-quality standards on the engagement, review

designs, and mentor engineers - including Innover's delivery pods that support

the account.

• Bridge

to delivery. Connect

the client to the wider Innover team, decomposing work into clear, reusable,

API-driven modules that pods can build against.

What you'll bring

Engineering foundation

• 12+

years designing and shipping scalable SaaS / B2B platforms end to end, with a

track record of owning technical direction.

• Deep,

hands-on expertise across the stack: Node.js, React / Next.js, TypeScript, and Python.

• Cloud-native

delivery on AWS (Lambda,

ECS/EC2, S3, RDS, API Gateway), with Docker, Kubernetes, and CI/CD.

• Strong

data and architecture chops: PostgreSQL, DynamoDB, Redis/SQL; microservices, event-driven and

distributed systems, multi-tenant design.

• Full

SDLC ownership - architecture,

build, test, deploy, and production support - not just feature work.

AI-native engineering

(non-negotiable)

This is the differentiator. We

want engineers who genuinely build this way today, not who list the tools:

• Daily

production use of agentic coding tools (Claude Code, Cursor, and similar) as core to the workflow.

• Experience

authoring project conventions and guardrails (e.g. CLAUDE.md, structured prompts) that curb LLM failure

modes - hallucinated APIs, type-system bypasses, scope creep.

• AI-augmented

CI/CD: automated code

review, test generation, and security analysis - with a habit of measuring the

effect on speed and defect rates before scaling adoption.

• Judgment

on tooling: matching

models to task type on cost and capability, and coaching engineers of varying

AI fluency. RAG / agentic patterns are a plus.

Client-facing strength

• Comfortable

partnering directly with CTOs, product leaders, and executives; can hold the

room and earn trust.

• Proven

ability to operate under ambiguity and drive to an outcome without a

fully-specified brief.

• Based

in the US and authorized to work in the US.

Nice to have

• Domain

depth in a client vertical (e.g. financial services, real estate,

manufacturing, logistics).

• Architecture-review

or design-standards leadership at scale (e.g. chairing an Architecture Review

Board).

• Serverless-first

design, observability (Datadog, CloudWatch, OpenTelemetry), Terraform/IaC, and

security fluency (OAuth2/OIDC, SOC 2, RLS, KMS/IAM).

• Patents,

open-source, or shipped side projects that show you build with these tools for

real.