Software Engineer

The Role

We are looking for a high-agency Software Engineer to help build the core systems behind Constellation

OS — an autonomous operating system for satellite networks.

Constellation

OS 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
• 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.

• 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 to state to 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

• You identify problems before they are written down and take ownership from idea to system to production

• You deeply understand distributed systems, networking, operating systems, and concurrency
• You think in terms of throughput, latency, consistency, and failure modes

• You are comfortable working in C++ and/or Rust
• You understand memory, threading, and performance at a systems level

• 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

• You can operate in ambiguous environments and work directly with technical users

• You thrive in high-velocity environments where ownership is high and ambiguity is normal

• 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)

You should be comfortable reasoning about systems where software interacts with the physical world, even if you have not worked in the space domain before.

• Base salary: $120,000 – $180,000 USD
• Meani…