Software Engineer

Constellation Space•Seattle, WA

3d•Onsite

About The Position

We are looking for a high-agency Software Engineer to help build the core systems behind ConstellationOS — an autonomous operating system for satellite networks. ConstellationOS is not a traditional backend system. It is a real-time, closed-loop decision engine that ingests 100,000+ telemetry messages per second, maintains a deterministic world model of a live satellite network, predicts link degradation and network failures ahead of time, and generates and executes autonomous rerouting decisions under real-world constraints. This is a system where software directly interacts with a physical network. Latency, correctness, and reliability are not abstractions—they determine whether the system works. You will work directly with the founders to design and build systems at the intersection of distributed systems, networking, and real-world physical constraints. This role is based in Seattle, WA. This role is best suited for engineers who enjoy working on complex systems with real-world constraints. It is not a good fit for engineers looking for purely CRUD or API-focused work.

Requirements

High Agency: You identify problems before they are written down and take ownership from idea → system → production
Systems-Minded: You deeply understand distributed systems, networking, operating systems, and concurrency. You think in terms of throughput, latency, consistency, and failure modes.
Low-Level Fluent: You are comfortable working in C++ and/or Rust. You understand memory, threading, and performance at a systems level.
Comfortable with Complexity: You enjoy systems where software interacts with the real world (latency, geometry, resource constraints, environmental effects). You are excited by problems that don’t have clean abstractions.
Customer-Ready: You can operate in ambiguous environments and work directly with technical users.
Startup-Calibrated: You thrive in high-velocity environments where ownership is high and ambiguity is normal.

Nice To Haves

Experience with high-throughput or real-time systems (event-driven architectures, streaming pipelines)
Background in networking (TCP/UDP, routing, distributed protocols)
Experience with simulation frameworks (e.g., Basilisk, ROS, Gazebo, game engines, or custom physics systems)
Exposure to satellite systems, orbital data, or ground segment infrastructure (e.g., SATCAT, TLEs, GSaaS)
Experience modeling real-world systems under physical constraints (RF, robotics, aerospace, etc.)
Experience with ML systems in production (especially inference pipelines)
Comfortable reasoning about systems where software interacts with the physical world, even if you have not worked in the space domain before.

Responsibilities

Build and evolve the core “world model” of a satellite network, combining telemetry, predictions, and system state into a deterministic, queryable system
Design systems that can replay, simulate, and reason about network behavior over time
Design and operate high-throughput, event-driven systems (target: 100k+ msgs/sec sustained)
Ensure strict guarantees around latency, ordering, and system stability under load
Build low-latency components in C++ and/or Rust
Own concurrency models, memory efficiency, and profiling of critical paths (telemetry → state → decision)
Optimize for sub-second end-to-end reaction times
Implement pipelines that transform predictions into actionable decisions
Design scoring, optimization, and constraint-based systems for routing and scheduling under real-world limits (bandwidth, visibility, power)
Deploy and operate distributed systems in AWS (or equivalent)
Build observability into everything: latency, throughput, system health, and decision quality
Work directly with customers in operational environments
Debug live systems, integrate with ground segment and control systems, and iterate rapidly
Contribute to operator-facing systems to ensure decisions are visible, interpretable, and actionable