Forward Deployed Engineer (FDE)

Position Summary

This Lead Developer serves as the technical bridge between our Forward Deployed Engineer (FDE)and the offshore development team. The role translates high-level architectural direction and productrequirements into actionable, well-scoped work for offshore delivery, while maintaining code quality,architectural compliance, and alignment with Charter engineering standards.

This is a hands-on technical leadership role, aligned to the Charter Software Engineering Team Leadmodel. Roughly half the time is spent contributing code directly; the rest is spent on technicalownership, delivery coordination, and enabling the offshore team. The lead leads through technicalcontext and influence, not formal management authority.

The core of this role is a strong hands-on technical engineer with real leadership experience. The twothings that matter most are (1) demonstrated technical leadership of a development team and (2)deep backend Python skills (FastAPI/Flask, async, Pydantic, REST API design).

Key Responsibilities

Offshore Liaison

•                     Translate FDE-defined architectural decisions, designs, and product requirements into detailedtechnical specifications and user stories consumable by the offshore development team

•                     Serve as the primary escalation point for offshore developers encountering technical blockers

•                     Participate in sprint ceremonies (planning, daily standups, reviews) with the offshore team,bridging timezone gaps with asynchronous documentation and recorded walkthroughs

•                     Coordinate with the FDE on priorities, scope changes, and technical direction; relay context anddecisions to the offshore team

Technical Ownership

•                     Own day-to-day technical decisions for the team's area: implementation approach, internal design,refactoring, and production support strategy

•                     Apply architectural standards in practice; push back when direction does not fit real-worldconstraints

•                     Represent the team in architecture and cross-team technical conversations

•                     Set expectations for code review, testing, documentation, and production readiness

•                     Conduct code reviews for all offshore-produced work, ensuring compliance with Charter codingstandards, constraints, and CI/CD pipeline requirements

•                     Maintain and enforce adherence to contract-first API design (OpenAPI 3.0+ specs authored beforeimplementation)

•                     Keep technical debt visible and advocate for engineering time to address it

•                     Lead the technical response to incidents — debugging, root cause analysis, and durable fixes

•                     Own operational health for the team's area: monitoring, alerting, on-call health, and runbooks

•                     Drive release readiness and track post-release outcomes with the Product Owner and customers

Delivery and Execution

•                     Ensure new work is captured in Jira with enough detail to be actionable: context, dependencies,acceptance criteria, testing expectations

•                     Help the team break down larger work into realistic, executable pieces

•                     Lead planning discussions with estimates grounded in actual technical complexity

•                     Ensure offshore deliverables pass automated quality gates (linting, static analysis, unit tests,integration tests) before entering the review pipeline

•                     Manage merge request flow: enforce branching strategy, pipeline compliance, and deploymentreadiness

•                     Remove technical blockers and facilitate decisions when the team is stuck

•                     Continuously improve how the team delivers (tooling, automation), not just what it delivers

•                     Raise timeline, scope, and dependency risks early

Team Enablement and Technical Leadership

•                     Provide managers with clear, specific input on technical performance, delivery, and growth; makestrong contributions visible and raise underperformance concerns early with factual examples

•                     Own the technical side of onboarding new engineers, including offshore team members

•                     Mentor engineers on technical judgment, tradeoffs, and execution, and on Charter platformpatterns, shared libraries, and internal tooling

•                     Encourage knowledge sharing and documentation so systems aren't dependent on one person

Required Technical Expertise

Backend Development

•                     Python — FastAPI, Flask; deep knowledge of async patterns, dependency injection, Pydanticvalidation

•                     Packaging and distribution via internal PyPI (JFrog Artifactory)

•                     Node.js — service development, npm ecosystem

•                     Microservice architecture — Domain-Driven Design (DDD), bounded contexts, servicedecomposition

•                     Shared library design — building and maintaining common packages consumed across services

API Design and Integration

•                     REST API design following Spectrum Business standards (contract-first OpenAPI 3.0+, URL pathversioning, JSON/camelCase, HATEOAS)

•                     API Gateway experience

•                     Three-tier error classification (Protocol, Application, Domain errors)

•                     Async job handling patterns (202 Accepted + polling)

•                     Idempotency key implementation for state-changing operations

•                     API versioning strategy — N-1 support, deprecation lifecycle, sunset headers

•                     Service-to-service communication — OAuth 2.0 Client Credentials flow, inter-service clientpatterns

Frontend (Working Knowledge)

•                     React — functional components, hooks, Redux Toolkit state management

•                     Micro-Frontend (MFE) architecture — understanding of Module Federation, remote applicationloading, independently deployed modules on the Galaxy platform

•                     Ability to review frontend code for correctness, security (no secrets in client code), and adherenceto team coding standards (SCSS, relative units, component structure)

•                     Comfortable reading TypeScript and providing meaningful code review feedback

•                     Understanding of ReactJS Reusable Component Library and Design Library patterns

Databases

•                     PostgreSQL — schema design, query optimization, Alembic migrations, CDC replication setup

•                     Oracle — read/query patterns for legacy system integration

•                     SQL Server — cross-platform query compatibility

Infrastructure and CI/CD

•                     GitLab CI/CD — pipeline design, multi-environment deployment via branch strategy and job splits

•                     Docker / containerization — Dockerfile authoring, image optimization, layer efficiency

•                     Kubernetes (OpenShift/RKE2) — pod deployment, service configuration, cert-manager, Reloader,health probes

•                     Linux (RHEL) — server administration, troubleshooting

•                     Helm chart management and deployment patterns

Observability and Monitoring

•                     Datadog — APM instrumentation, dashboard creation, monitor configuration, structured logging

•                     Distributed tracing — correlation ID propagation (X-Correlation-ID), OpenTelemetry spans

•                     Log management — structured JSON logging, Flask-Log-Request-ID, ddtrace integration

•                     Kafka-specific monitoring — consumer lag alerts, broker health, connector status (applies asevent-driven usage grows; see the Event-Driven Architecture note above)

•                     RED metrics (Request rate, Error rate, Duration) and USE metrics for infrastructure resources

Testing and Quality

•                     Unit testing: pytest (Python), Jest (React) — minimum 70% code coverage

•                     Integration testing: 80% integration-point coverage, external dependency mocking

•                     Automated backward compatibility testing for APIs

•                     Consumer-driven contract testing (Pact-style)

•                     Performance baseline documentation and load testing

•                     Event-driven testing — testing async workflows, verifying message production/consumption,schema compatibility testing (relevant as event-driven usage grows; see the Event-DrivenArchitecture note above)

Security

•                     OAuth 2.0 / Keycloak integration — Client Credentials flow, JWT validation

•                     mTLS for service-to-service communication

•                     Federated authentication (LDAP, Charter Corporate IT)

•                     Secrets management via Kubernetes Secrets (cert-manager pattern) for credential delivery

•                     Kafka security — TLS encryption, SASL/SCRAM authentication, topic-level ACLs (relevant as event-driven usage grows; see the Event-Driven Architecture note above)

Required Soft Skills

•                     Clear written and verbal communication — ability to produce documentation that removesambiguity for offshore teams operating asynchronously

•                     Technical leadership without direct authority — influence through expertise and clear reasoning

•                     Cross-cultural communication awareness — experience working with geographically distributedteams across timezones

•                     Conflict resolution — ability to mediate technical disagreements between FDE direction andoffshore implementation realities

•                     Prioritization under pressure — comfort triaging competing requests and communicating tradeoffs

Preferred Qualifications

•                     8+ years of professional backend software development experience

•                     3+ years leading or coordinating distributed/offshore development teams

•                     Experience with Domain-Driven Design (DDD) methodology and C4 architecture documentation

•                     Familiarity with Jira for sprint/backlog management and issue tracking

•                     Experience producing and maintaining technical documentation

•                     Exposure to network automation, telecom/ISP provisioning systems, or enterprise IPAM platforms

•                     Any hands-on Kafka / event-driven experience — designing or operating event pipelines, ormigrating systems from synchronous request/response to event-driven patterns — is a nice-to-have plus, not a requirement

Work Environment

•                     Schedule: Must have meaningful overlap with both US-based FDE working hours and offshoreteam working hours (typically requires flexibility in early morning or late afternoon hours)

•                     Tools: GitLab, Jira, Confluence, Datadog, Kiro IDE

Reporting Structure and Working Relationships

•                     Reports to: Development Manager, Charter

•                     Works closely with: Forward Deployed Engineer, Offshore Team Lead, QA Lead, Scrum Master

•                     Dotted-line coordination with: Domain Architects (for standards alignment)

Key partnerships:

•                     Lead–Manager: Managers hold authority; the lead holds technical context. The partnership workswhen managers trust and act on the lead's technical input, and the lead communicates early,clearly, and in business terms when needed. Lead input is advisory but meaningful.

•                     Product Owner: align on scope, backlog readiness, and tradeoffs.

•                     Scrum Master: partner on flow, ceremonies, and blocker escalation.

•                     Architecture / Principal Engineers (incl. the FDE): align implementation with broader standards.

•                     Developers (onshore and offshore): support execution, mentoring, and technical clarity.

Success Metrics

•                     Offshore team velocity sustained or improved quarter over quarter

•                     Code review turnaround time under 24 hours for standard MRs

•                     Zero architectural drift — offshore deliverables pass Keystone constraint validation

•                     Reduction in rework cycles (rejected MRs) over first 6 months

•                     Offshore team independently resolves 80%+ of technical questions via documentation (reducedescalation rate)