Senior Full-Stack / Developer Platform Engineer

Position: Senior Full-Stack / Developer Platform Engineer
About the project
The project is an enterprise-grade AI-powered legacy modernization and full-stack software development platform that automates the complete software development lifecycle. We use advanced LLM agents (Claude Sonnet 4, GPT-4o) to transform business requirements into production-ready, deployable applications across multiple target languages and frameworks.
Our platform generates complete, buildable, testable code for greenfield and brownfield modernization scenarios, supporting enterprise migrations from source tech stacks (VB6, PHP, ASP, JAVA, .NET, etc.) to modern cloud-native stacks.
Role Overview
We're seeking an exceptional Senior Full-Stack / Developer Platform Engineer who will own the Developer Agent pipeline — the core code generation engine that transforms architectural specifications into production-ready, multi-language implementations. This role requires deep expertise across multiple programming languages, strong full-stack development capabilities, and the ability to build robust developer tooling systems.
You'll be responsible for:
Developer Agent Pipeline: Owning the parallel sub-agent dispatch system that generates code for multiple components simultaneously
Code Generation Quality: Implementing validation frameworks that ensure generated code is complete, correct, secure, and deployable
Multi-Language Support: Building and maintaining code generation templates, scaffolding systems, and validation rules for Java, C#, VB, Python, PHP, TypeScript, Java, and emerging languages
Artifact Management: Managing output artifacts, file structures, Docker containers, and deployment packages across target stacks
Greenfield Scenarios: Supporting enterprise teams building entirely new applications from requirements without legacy code
This is a hands-on technical leadership role where you'll write code daily, design complex systems, and set quality standards for AI-generated software.
Core Responsibilities
1. Developer Agent Pipeline Ownership
Primary System: The orchestration engine for parallel code generation
Key Responsibilities:
Design and maintain the Developer Agent decomposition logic that breaks architectural specs into componentizable units
Build the parallel sub-agent dispatch system that spawns lightweight code-generation agents for each component
Implement work scheduling, dependency resolution, and phase-based execution for multi-component systems
Create component-scoped handoff packages that provide each sub-agent with precise context
Optimize throughput: reduce total pipeline time while maintaining quality across parallel executions
Handle failures gracefully: implement retry logic, fallback strategies, and error aggregation
Monitor and tune concurrency levels (currently 5 parallel agents, scalable to 10+)
Technical Deep-Dive:
Work with concurrent threads for parallel LLM invocations
Design JSON Schema contracts for sub-agent inputs/outputs
Build deterministic fallback generators for high-confidence scenarios (auth slices, UI scaffolds)
Implement component prerequisite checking and blocking logic
2. Code Generation Quality & Validation
Primary Systems:
Semantic validation framework in DeveloperSubAgent._semantic_validation_errors()
Multi-stage validation: structural → semantic → security → completeness
Key Responsibilities:
Build validation rules that catch incomplete, insecure, or non-functional generated code
Implement contract compliance checks: verify all API endpoints, request/response DTOs, and business rules are present in code
Create language-specific quality gates (e.g., .NET 8 alignment for C#, dependency pinning for Python)
Design security validators: check for placeholder auth, hardcoded credentials, missing input validation
Build completeness checks: ensure Dockerfile, tests, health endpoints, and dependency files are present
Implement regression anchor validation for brownfield modernization scenarios
Create remediation prompt generators that guide LLMs to fix specific validation failures
Quality Dimensions You'll Enforce:
Structural Completeness: All required files present (Program.cs, Dockerfile, tests, etc.)
Contract Fidelity: Every interface contract has matching controller/handler code
Security Baseline: No placeholder logic, JWT validation, input sanitization, non-root Docker users
Test Coverage: At least one executable test per non-health contract
Persistence Layer: Real repository/data-access code when data ownership is in scope
UI Scaffold Compliance: Screen Contracts honored, render profile rules applied
Build/Deploy Ready: Docker builds succeed, health endpoints respond, K8s manifests valid
3. Multi-Language Code Generation
Languages: ReactJs/VueJs/Angular, JQuery, .NETCORE, C#/.NET, Python, TypeScript/Node.js, Java/Spring Boot, PHP, ASP.NET
Key Responsibilities:
Build language-specific code generation templates and scaffolding systems
Create framework-aligned project structures (ASP.NET Core, FastAPI, Express, Spring Boot)
Design dependency management strategies: requirements.txt, package.json, .csproj, go.mod
Implement language-specific validation rules and linting integration
Build Dockerfile templates optimized for each language ecosystem
Create test framework scaffolds: pytest, xUnit, Jest, JUnit
Design CI/CD pipeline templates for each target stack
What You'll Build for client projects using our AI Platform:
C# Scaffolds: Razor Pages with PageModel wiring, Controllers + Services + Repository pattern, .NET 8 project files, xUnit tests
Python Scaffolds: FastAPI routers, Pydantic models, SQLAlchemy repositories, pytest fixtures
TypeScript Scaffolds: Express routes, Zod validation, TypeORM entities, Jest tests
ReactJs, Angular, Vue, Nest.Js
Java Scaffolds: Spring Boot controllers, JPA entities, service layers, JUnit 5 tests
Deterministic Slices: Pre-built, high-quality code for common patterns (auth, CRUD, health checks)
SQL Server/MySQL/Oracle/PostgreSQL
4. Full-Stack Development & Maintenance
Primary Responsibilities:
Develop and maintain the AI platform itself (dogfooding)
Build web UI features for the Developer Agent control panel
Create artifact preview/download systems
Implement real-time code generation streaming
Design debugging tools for generated code inspection
Build artifact comparison tools for reviewing AI outputs
Tech Stack You'll Work With:
Backend: Python, Starlette/FastAPI, async/await patterns
Frontend: Vanilla JavaScript, Tailwind CSS, server-rendered templates
APIs: REST, streaming endpoints, WebSockets for live updates
Storage: Firestore, Google Cloud Storage, local filesystem
Deployment: Docker, Cloud Run, Kubernetes
Example Features:
Live code generation progress dashboard
Side-by-side diff viewer for legacy vs. generated code
Interactive artifact browser with syntax highlighting
One-click deployment to preview environments
Code quality scorecard visualization

5. Greenfield Enterprise Scenarios
Key Responsibilities:
Support teams building new applications from scratch (no legacy code)
Design requirements → architecture → code workflows without brownfield constraints
Build template libraries for common enterprise patterns
Create industry-specific scaffolds (fintech, healthcare, e-commerce)
Implement best-practice enforcement for greenfield projects
Greenfield Capabilities You'll Enable:
Industry Templates: Pre-built scaffolds for banking, healthcare, retail domains
Compliance Baselines: HIPAA, PCI-DSS, SOC 2 code generation rules
Architecture Patterns: Microservices, event-driven, CQRS, hexagonal architecture
Reference Implementations: Working examples for common enterprise scenarios
Quality Gates: Stricter validation rules for production-grade greenfield code

Required Technical Skills
Programming Languages (Expert Level)
Must have expert-level proficiency in at least TWO of the following:
C# / .NET (8+ years preferred)
ASP.NET Core, Razor Pages, Web API, Entity Framework Core
.NET 8 features, minimal APIs, dependency injection
xUnit, Moq, integration testing patterns
NuGet package management, .csproj file structure
Java / Spring Boot (8+ years preferred)
Spring Boot 3.x, Spring MVC, Spring Data JPA
Maven/Gradle, dependency management
JUnit 5, MockMVC, test containers
Modern Java features (records, sealed classes, pattern matching)
Python (8+ years preferred)
FastAPI, Flask, Django
Pydantic, SQLAlchemy, pytest
Type hints, dataclasses, async/await
Dependency management (pip, poetry, uv)
TypeScript / Node.js (6+ years preferred)
Express, NestJS, Fastify
TypeORM, Prisma, Sequelize
Jest, supertest, integration testing
Modern TypeScript features (decorators, generics, utility types)
PHP (6+ years preferred)
Laravel, Symfony frameworks
Composer, PSR standards
PHPUnit testing
Modern PHP 8+ features
Developer Tooling & Code Generation (Required)
Code Scaffolding Systems: Yeoman, Plop, custom generators
Template Engines: Jinja2, Handlebars, custom string interpolation
AST Manipulation: Understanding of Abstract Syntax Trees for code transformation
Parsing Libraries: tree-sitter, language-specific parsers
Code Analysis: Static analysis tools (SonarQube, ESLint, Pylint, Roslyn analyzers)
Project Generators: CLI tools that scaffold project structures
Validation & Quality Engineering (Required)
JSON Schema: Contract validation, schema design, version management
Structural Validation: File presence checks, project structure verification
Semantic Validation: Code analysis for completeness and correctness
Security Validation: OWASP Top 10, input validation, auth/authz patterns
Test Automation: Building test harnesses, E2E test frameworks
Container & Deployment Technologies (Required)
Docker: Multi-stage builds, optimization, security hardening
Dockerfile Best Practices: Layer caching, non-root users, health checks
Kubernetes: Deployments, services, ConfigMaps, health probes
CI/CD: GitHub Actions, Cloud Build, pipeline as code
Container Registries: GCR, Docker Hub, artifact management
AI/LLM Integration (Required)
LLM APIs: Experience with Claude, GPT-4, or similar models
Prompt Engineering: Crafting structured prompts for code generation
Structured Outputs: JSON Schema, function calling, tool use
Quality Loops: Retry logic, validation feedback, iterative refinement
Token Optimization: Managing context windows, cost reduction strategies
Full-Stack Web Development (Required)
Backend Frameworks: Starlette, FastAPI, Flask, Express
Frontend: JavaScript/TypeScript, HTML/CSS, Tailwind CSS
API Design: REST, GraphQL, WebSockets, streaming
Authentication: JWT, OAuth2, session management
Databases: PostgreSQL, MySQL, NoSQL (Firestore, MongoDB)

Required Domain Knowledge
Software Architecture Patterns
Microservices: Service boundaries, API gateways, inter-service communication
Layered Architecture: Controllers, services, repositories, DTOs
Domain-Driven Design: Entities, aggregates, repositories, domain services
Event-Driven: Message queues, event sourcing, CQRS
Hexagonal Architecture: Ports and adapters, dependency inversion
Enterprise Development Practices
12-Factor App: Configuration, statelessness, disposability
Security Best Practices: Input validation, auth/authz, secrets management
Logging & Monitoring: Structured logging, metrics, tracing
Error Handling: Exception hierarchies, error responses, resilience patterns
API Versioning: Semantic versioning, backwards compatibility
Legacy Modernization Patterns
Strangler Fig: Incremental replacement of legacy systems
Anti-Corruption Layer: Isolating legacy interfaces
Database Migration: Schema evolution, data migration strategies
Behavioral Parity: Preserving legacy functionality in modern implementations
Regression Testing: Anchor-based testing for brownfield scenarios
Code Quality Standards
SOLID Principles: Single responsibility, open-closed, Liskov substitution
Clean Code: Naming conventions, function size, complexity management
Test Pyramid: Unit, integration, E2E test ratios
Code Coverage: Statement, branch, path coverage strategies
Static Analysis: Linting rules, code smell detection

Required Soft Skills & Attributes
Technical Leadership
Ownership Mindset: End-to-end responsibility for the Developer Agent subsystem
Quality Obsession: Zero tolerance for non-functional generated code
Systems Thinking: Understanding how code generation fits into the broader platform
Performance Focus: Optimizing for throughput, latency, and cost efficiency
Security Consciousness: Building secure code generation patterns
Problem-Solving Excellence
Deep Debugging: Investigating complex code generation failures
Pattern Recognition: Identifying common failure modes and building preventions
Root Cause Analysis: Tracing issues from symptoms to underlying causes
Pragmatic Tradeoffs: Balancing perfection with shipping working solutions
Continuous Improvement: Iteratively enhancing quality and reliability
Communication & Collaboration
Technical Writing: Documentation, design specs, post-mortems
Code Review: Providing constructive feedback, mentoring junior engineers
Stakeholder Management: Explaining technical concepts to non-technical users
Cross-Team Collaboration: Working with Architect Agent, Tester Agent, and UI Scaffold teams
Knowledge Sharing: Creating runbooks, best practices, training materials
AI Collaboration Expertise
Prompt Crafting: Writing effective prompts for code generation agents
Output Validation: Critically evaluating LLM-generated code
Feedback Loops: Designing retry mechanisms with remediation guidance
Model Behavior: Understanding LLM strengths, limitations, and failure modes
Human-in-the-Loop: Knowing when to escalate to manual intervention

Day-to-Day Activities
Typical Week Breakdown
Development (50%): Writing code for new features, fixing bugs, optimizing performance
Code Generation Quality (20%): Building validation rules, analyzing failure patterns, tuning prompts
Code Review & Mentoring (15%): Reviewing PRs, helping team members, pair programming
Architecture & Design (10%): Designing new language support, system improvements, technical specs
Meetings & Planning (5%): Standups, sprint planning, technical discussions
Example Daily Tasks
Monday:
Morning: Review weekend code generation failure reports, triage issues
Afternoon: Implement new validation rule for Spring Boot security configurations
Evening: Code review for TypeScript scaffold improvements
Tuesday:
Morning: Design session for Go language support architecture
Afternoon: Build deterministic auth slice template for FastAPI
Evening: Update documentation for multi-language artifact management
Wednesday:
Morning: Debug complex C# code generation failure (missing EF Core migrations)
Afternoon: Optimize parallel sub-agent dispatch for 10-component systems
Evening: Mentor junior engineer on semantic validation framework
Thursday:
Morning: Implement Screen Contract → React component generation
Afternoon: Build quality dashboard for generated code metrics
Evening: Sprint planning and backlog grooming
Friday:
Morning: Performance optimization: reduce Developer Agent latency by 30%
Afternoon: Write technical blog post on AI code generation best practices
Evening: Demo new greenfield scaffold to product team

Technology Stack Deep-Dive
Core Development Environment
Languages: Python 3.11+, JavaScript/TypeScript, C#, Java
Frameworks: LangGraph (orchestration), LangChain (agent patterns)
LLM Providers: Anthropic Claude Sonnet 4, OpenAI GPT-4o, Azure OpenAI
Web Framework: Starlette (async ASGI)
Testing: pytest, xUnit, Jest, JUnit, Playwright
Code Analysis: tree-sitter, pglast (SQL), jsonschema, OpenAPI validator
Code Generation Stack
Template Engines: Jinja2, custom string templating
AST Libraries: ast (Python), Roslyn (C#), TypeScript Compiler API
Validation: JSON Schema Draft 2020-12, custom semantic validators
Parsers: tree-sitter-language-pack, phply (PHP), custom parsers
Linters: Ruff (Python), ESLint (JS/TS), Roslyn analyzers (C#), SonarQube
Infrastructure & Deployment
Cloud Platform: Google Cloud Platform (primary)
Compute: Cloud Run (serverless containers), Kubernetes (preview deployments)
Storage: Firestore (state), GCS (artifacts), Cloud Tasks (queuing)
CI/CD: GitHub Actions, Cloud Build, automated testing pipelines
Containers: Docker 20+, multi-stage builds, security scanning
Developer Tooling
Version Control: Git + GitHub (required proficiency)
IDE: VS Code with Copilot (highly recommended)
Package Managers: pip/uv (Python), npm/yarn (Node), NuGet (C#), Maven/Gradle (Java)
API Testing: httpx, Postman, curl
Debugging: VS Code debugger, pdb (Python), Chrome DevTools (JS)
Monitoring & Observability
Logging: Cloud Logging, structured JSON logs
Metrics: Custom dashboards, code generation success rates, latency percentiles
Tracing: Distributed tracing for multi-agent pipelines
Alerting: Automated failure notifications, quality threshold breaches