Platform Engineer

Our software flies drones in combat — not in a demo, not in a simulation, but in the field, every day. eyesAtop builds the operating system for multi-drone warfare: one platform that lets a single operator plan, task, and execute complex multi-drone missions across ISR, logistics, and strike in real time.

None of that ships without the layer underneath it. We're hiring a Platform Engineer to own the infrastructure, build systems, and developer platform that let our team move at the speed the mission demands — from a laptop commit to a container running on an edge compute node in a contested environment.

Here's what makes this role different: we're building our developer ecosystem in the middle of the agentic coding shift. Engineering teams everywhere are about to produce 10x the code, 10x the commits, 10x the test runs — and most CI pipelines, review workflows, and version control setups weren't designed for that. We don't have 25 years of legacy tooling to unwind. You'll design a platform that's agent-native from day one, where AI amplifies good engineering fundamentals instead of amplifying chaos.

This is a founding-level role on our Austin platform team. You won't be inheriting a mature internal platform and keeping the lights on; you'll be building it, and setting the standards the rest of the US engineering org builds on.

What You'll Do

Build the core platform

• Design and own the CI/CD pipelines that take our Java, C++, and Python services from commit to deployment — across cloud, on-prem, and disconnected edge targets
• Build and maintain multi-architecture build and release pipelines, including ARM64 for NVIDIA Jetson / Orin edge compute nodes running onboard AI and mission logic
• Own our containerization and orchestration strategy for both server-side and edge workloads
• Manage infrastructure as code so environments are reproducible, auditable, and fast to stand up — for development, test, lab, and field deployments
• Design deployment and update paths that hold up in degraded, contested, and air-gapped environments — where you can't assume connectivity or a cloud backhaul

Make it agent-ready

• Architect build, test, and CI capacity for a world where AI agents generate a large share of commits — plan for order-of-magnitude growth in build frequency, test execution, and change volume before it becomes the bottleneck
• Design a validation strategy that scales: fast, trustworthy test signals that both humans and coding agents can rely on, with smart test selection rather than "run everything, always"
• Build guardrails and sandboxed environments so agent-generated code can be developed and evaluated safely — strict isolation between experimental work and the software that ships to the field
• Treat internal APIs and data as if they were public: authentication, authorization, rate limiting, and audit for every service, because agents will find and call anything that's reachable
• Own AI tooling infrastructure and token economics — visibility into where inference spend goes, budgets and quotas per team/pipeline, and ensuring no load-bearing workflow (like a rollback path) silently depends on an agent having budget left
• Provide the opinionated abstractions — standard frameworks, golden paths, paved roads — that keep both human and agent contributors from making bad choices at scale

Keep humans in control

• Build observability, logging, and monitoring across the platform so we can debug behavior across software, networking, devices, and field conditions — and maintain intellectual control of the codebase as it grows faster than any one person can read it
• Instrument code review and merge workflows so review stays a quality gate, not a rubber stamp, as change volume climbs
• Partner with our security and compliance efforts (CMMC Level 2, NDAA-compliant hardware, secure SDLC) and bake those requirements into the pipeline rather than bolting them on later — including provenance and attestation for agent-generated changes
• Work directly with software engineers, systems integrators, and hardware teams to make sure the platform actually serves how the product gets built and fielded

Requirements

• 4+ years in platform engineering, DevOps, infrastructure, or a closely related software engineering role
• Strong command of CI/CD systems (e.g. GitHub Actions, GitLab CI, Jenkins, Argo) and a track record of building pipelines others depend on
• Deep comfort with containers (Docker) and container orchestration concepts, plus the judgment to right-size orchestration for the problem
• Infrastructure as code proficiency (Terraform, Pulumi, Ansible, or equivalent)
• Solid Linux administration and networking fundamentals (TCP/IP, DNS, routing, firewalls) — you're comfortable when things break below the application layer
• A scripting/automation language you reach for by reflex (Python, Bash, Go, or similar)
• Hands-on experience with AI-assisted development workflows (Claude Code, Copilot, Cursor, or agentic pipelines) — and a point of view on where they help, where they hurt, and how a platform should constrain them
• A systems-thinking mindset: you see the developer ecosystem as a whole — build, test, review, release, rollback — and you know that changing one node changes them all
• A "developers are my customers" instinct: you measure success by how fast and safely the team around you can ship

Strong fit if

• Experience shipping to edge or embedded targets — ARM64, NVIDIA Jetson / Orin, or resource-constrained hardware
• Experience with deployments in disconnected, degraded, or air-gapped environments
• Experience operating LLM/inference infrastructure, agent orchestration, or MCP-based tooling in a production engineering org
• Familiarity with defense or regulated-industry compliance: CMMC, NIST 800-171, FedRAMP, ITAR/EAR, or supply-chain security
• Background supporting mixed-language builds (Java + C++ + Python)
• Exposure to robotics, drones, C2 systems, or real-time/mission-critical software