| Job Description: |
Key Responsibilities
Offshore Liaison
Translate FDE-defined architectural decisions, designs, and product requirements into detailed
technical 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 and
decisions 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-world
constraints
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 coding
standards, constraints, and CI/CD pipeline requirements
Maintain and enforce adherence to contract-first API design (OpenAPI 3.0+ specs authored before
implementation)
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 deployment
readiness
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; make
strong 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 platform
patterns, 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, Pydantic
validation
Packaging and distribution via internal PyPI (JFrog Artifactory)
Node.js — service development, npm ecosystem
Microservice architecture — Domain-Driven Design (DDD), bounded contexts, service
decomposition
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 path
versioning, 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 client
patterns
Frontend (Working Knowledge)
React — functional components, hooks, Redux Toolkit state management
Micro-Frontend (MFE) architecture — understanding of Module Federation, remote application
loading, independently deployed modules on the Galaxy platform
Ability to review frontend code for correctness, security (no secrets in client code), and adherence
to 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 as
event-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-Driven
Architecture 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 eventdriven usage grows; see the Event-Driven Architecture note above)
Required Soft Skills
Clear written and verbal communication — ability to produce documentation that removes
ambiguity for offshore teams operating asynchronously
Technical leadership without direct authority — influence through expertise and clear reasoning
Cross-cultural communication awareness — experience working with geographically distributed
teams across timezones
Conflict resolution — ability to mediate technical disagreements between FDE direction and
offshore 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, or
migrating systems from synchronous request/response to event-driven patterns — is a nice-tohave plus, not a requirement
Work Environment
Schedule: Must have meaningful overlap with both US-based FDE working hours and offshore
team 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 works
when 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 (reduced
escalation rate |
