Software Architect

Caliburn is an independent company under the Fathom5 PEO and is focused on building advanced software for tactical and robotic autonomous systems.

Caliburn develops TempestOS, a security-focused operating system built for autonomous and tactical systems operating in demanding environments.

The team works across software, edge computing, cybersecurity, robotics, and systems integration to build technology designed for environments where reliability and resilience are critical.

Architecture and Design

• Own the architecture of assigned TempestOS subsystems end to end: service boundaries, interfaces, data models, failure modes, and upgrade paths.
• Design for AI Native development. Our team employs AI agents in the design and development of code with our developers providing context and oversight.
• Produce written design artifacts at a level of detail a developer can implement without escalating for interpretation.
• Design for the constraints TempestOS operates under: resource-constrained edge hardware, DDIL links, container orchestration without a reachable control plane, and policy enforcement at runtime.
• Treat security posture as a first-order design input rather than a review gate: least privilege, supply chain attestation, and runtime integrity built into the design rather than bolted on.
• Make the tradeoffs explicit. Every significant decision carries a written rationale and the alternative that was rejected.
• Sequence and decompose designs so work can be parallelized across developers of varying experience without creating integration debt.

• Serve as design authority for changes to subsystems. Review proposals before implementation starts, not after the merge request lands.
• Enforce and mature standards for testing, interface versioning, documentation, and backward compatibility across TempestOS services. This includes updating AI governance documents.
• Identify architectural drift early and propose the correction while it is still cheap.
• Say no to designs that will not survive contact with a deployed system, and explain why in terms the author can act on.

• Pair with junior and mid-level developers on problems above their current level, with the goal that the goal for them to handle the next challenge on their own.
• Review code with intent to teach. Explain the reasoning behind the corrections over providing the fix.
• Break complex designs into scoped, implementable tasks that stretch a developer without setting them up to fail.
• Run design walkthroughs and internal technical sessions so architectural context is shared rather than held.
• Give direct, timely feedback on quality and delivery. Escalate persistent performance concerns to Engineering leadership.
• Build the bench. The measure is junior developers producing sound designs of their own within a year.

• Write production code against the TempestOS codebase.
• Prototype the risky part of a design and prove it before handing the rest off.
• Take the unglamorous work when it is the fastest path to unblocking the team.

• Work with the platform, applications, and field engineering teams so designs account for how the product is actually deployed, integrated, and supported.
• Support integration of partner payloads and capabilities as containerized services on TempestOS, including the interface and policy work that makes those integrations repeatable.
• Demonstrate progress at company demo days and customer engagements, and occasionally support bid and proposal activity where technical architectural inputs are needed.

• Eight or more years of professional software engineering experience, including significant time designing systems that other engineers implemented.
• Demonstrated architecture ownership of a system that shipped and operated under real conditions.
• Mastery of at least one statically typed systems language (Go, Rust, C, or C++), with the ability to work through advanced programming concepts. Go experience strongly preferred given the TempestOS stack.
• Deep Linux systems fluency: process model, filesystems, networking, containers, and the debugging tooling that goes with them.
• Familiar with AI development and coding tools and comfortable with AI Native development.
• Container and orchestration competence at a design level (Kubernetes, container runtimes, and image supply chain)
• Distributed systems fundamentals: service decomposition, message passing, consistency and partition behavior, and data serialization (Protocol Buffers, gRPC, or equivalent).
• Written and verbal communication strong enough that the design document itself is a primary deliverable, and clear enough to hold up in front of developers, management, and customers.
• Demonstrated mentorship. The candidate can point to engineers who got materially better because of them.
• US citizenship, required for clearance eligibility and customer site access.
• Active US Department of War Secret clearance, or the ability to obtain and maintain one over the duration of employment.

• Defense, maritime, naval, or autonomous systems domain experience; delivery of combat management or command and control software especially relevant.
• Experience with attribute-based access control, zero-trust architecture, policy engines (OPA/Rego), runtime integrity, or supply chain attestation.
• Experience with edge compute in DDIL environments and cloud-native development practices applied to network-disconnected systems.
• Familiarity with GitLab, Harbor, AlmaLinux, or comparable components.
• Fluency with AI-assisted development workflows, and judgment about where they belong in a safety- and security-critical codebase.
• Master's degree in computer science, electrical engineering, or a related field.
• Prior Navy, Marine Corps, or Joint service experience, particularly in engineering, cyber, or unmanned systems roles.

• Decisiveness over consensus. Makes the call with incomplete information and documents the reasoning.
• Honest about reality. Brings problems to the team rather than softening them.
• Teaching instinct. Gets satisfaction from an engineer's growth, not only from their own commits.
• Startup stamina. Caliburn is building at the intersection of tactical systems and advanced software. That occasionally means long hours, in-person work, and travel.

Additional information

Interested in joining the Caliburn team?

Apply today to help build the next generation of software for tactical and autonomous systems.