Learn about our culture to see if TAHO is a fit for you.

TAHO, Inc. is a remote-first software company with employees across the US on a shared mission to unlock computing hardware performance. We develop and sell TAHO (Trusted Autonomous Hybrid Operation), a software mesh designed for deployment and runtime architectures. We are focused on building category-defining technology in software, helping organizations drive better performance, efficiency, and adaptability. As a fast-growing startup, we are looking for team members who thrive in high-impact roles and embrace challenges.

As of August 2025, we have captured SEED funding, and we are pursuing additional customer traction. Our target is to achieve one million dollars in annual contract values by year-end 2025 and a one billion dollar valuation in three years. We are a first mover and category creator with pragmatic near-term goals. Join us for a once-in-a-lifetime opportunity to unlock true computing efficiency for the entire world.

We are hiring a Product Engineer to play a key role in building and scaling TAHO. This is a high-impact backend engineering position focused on core architecture, distributed system reliability, and high-performance computing. You will work on WebAssembly execution environments, decentralized runtime management, and low-latency communication—directly shaping how modern systems operate at scale. You should have experience building highly distributed, performance-critical backend systems with an emphasis on scalability, automation, and security. If you thrive in deep technical challenges and want to own and shape the backend architecture of a category-defining infrastructure product, this role is for you.

The mission of this role is to build the core systems that power TAHO’s next-generation computing platform, writing fast, reliable, and elegant code that makes distributed execution feel effortless. Operate with ownership, precision, and curiosity; move quickly from prototype to production while learning from every build cycle. The Product Engineer is not an isolated contributor. They are a part of the team that turns TAHO’s vision into a working, scalable reality.

This role requires a builder’s mindset: continuously improving, learning from senior engineers, and delivering production-quality work that compounds in value. The Product Engineer must fluidly switch between:

• Deep technical execution, writing and shipping Rust code that strengthens TAHO’s runtime reliability, performance, and security foundations.
• Collaborative development working closely with senior and staff engineers to design, review, and iterate on features that align with architectural priorities and product goals.
• Continuous improvement and learning drive measurable gains in code quality and performance, as well as in tooling and processes, while developing mastery in distributed systems and runtime design.

TAHO is a cutting-edge tech company that requires adaptability, a commitment to continuous learning, and innovative thinking to stay ahead in a rapidly evolving environment. Individuals must possess strong problem-solving skills and a customer-centric mindset, ensuring they can identify issues effectively while prioritizing customer needs. Collaboration and teamwork are crucial, as working well with others and contributing to a team-oriented culture drives success. While technical proficiency varies by role, a basic understanding of the company’s technology is beneficial, with deeper expertise essential for technical positions. Ultimately, thriving in such an environment hinges on the ability to adapt, learn, communicate, innovate, solve problems, and prioritize customers.

Responsibilities:

Backend Architecture & Development

• Contribute to designing and developing backend services for TAHO, using Rust, focusing on software deployment, runtime orchestration, and distributed execution.
• Develop high-performance WebAssembly (WASM) execution environments tailored for AI & HPC workloads.
• Optimize real-time workload scheduling, resource allocation, and automated failover mechanisms across systems.
• Participate in building secure and efficient data exchange mechanisms between distributed nodes using zero-trust networking models.
• Write secure, efficient code for node-to-node communication, using modern networking protocols (gRPC, Libp2p, etc.).

Compute & Scalability

• Contribute to designing and implementing scalable models that allow seamless interactions across heterogeneous computing environments (cloud, edge, on-prem).
• Develop tools for dynamic code streaming and live patching of TAHO-deployed AI workloads.
• Work on low-latency messaging protocols (DDS, gRPC, Libp2p, or custom P2P models) for decentralized coordination.

Performance Optimization & Security

• Participate in performance benchmarking and testing frameworks.
• Reduce cold start times and optimize high-density AI workload execution across multitenant architectures.
• Adopt AI-driven runtime optimizations, reducing inference energy consumption and improving hardware efficiency.
• Follow security-first development practices, enforcing container isolation, cryptographic verification, and secure enclave execution.

Collaborating & Learning

• Work closely with Staff and Senior engineers on feature design and implementation.
• Participate in code reviews, improving your own skills while helping raise code quality across the team.
• Learn and apply best practices for security, distributed computing, and runtime efficiency.

Qualifications:

• 3+ years of backend engineering experience in distributed systems, infrastructure, or multitenant architectures.
• Proficiency in Rust, Go, or C++ with a focus on high-performance, memory-safe backend services.
• Familiarity with WebAssembly (WASM), distributed runtimes, or sandboxed execution environments.
• Deep understanding of microservices, container orchestration (Kubernetes), and decentralized computing.
• Hands-on experience with low-latency networking, real-time communication protocols, and high-throughput data pipelines.
• Experience working with AI/ML inference pipelines, HPC environments, or learning architectures is a plus.
• Strong problem-solving skills and eagerness to learn from more senior engineers.

What to expect in the first 30 days:

• Initial build project (Weeks 1-2):
  
  • Complete a hands-on build project in Rust/WASM with guidance from senior engineers.
  • Showcase the project to the team at the end of two weeks, regardless of final state, as part of TAHO’s “everyone builds in the first two weeks” practice.
• Ship 1–2 small but production-quality contributions to TAHO’s Rust/WASM runtime.
• Add or extend at least 10–15 unit/integration tests improving test coverage for existing modules.
• Document onboarding learnings and propose 1 improvement to the dev workflow (docs, build tools, or CI pipeline).
• Pair-program with senior engineers to fix at least 2 identified bugs in the runtime execution path.

What to expect in the first 60 days:

• Deliver a standalone feature or enhancement (e.g., workload scheduling tweak, runtime metric export).
• Implement at least one performance benchmark for a critical runtime path.
• Contribute to error-handling or resilience mechanisms in distributed runtime components.
• Demo new work in an internal engineering sync and field peer feedback.

What to expect in the first 90 days:

• Ship 2+ features or enhancements to WASM execution or runtime orchestration.
• Build a small developer-facing tool or CLI command (e.g., runtime debug utility).
• Lead a focused refactor or cleanup effort, improving code quality in a subsystem.
• Contribute documentation updates (API usage, developer notes, or system diagrams).

What to expect in the first 6 months:

• Own and maintain at least one subsystem or feature area with minimal supervision.
• Deliver optimizations improving latency or throughput of a runtime path by measurable margin (e.g., 5–10%).
• Implement a small-scale reliability feature (e.g., health-check mechanism, self-healing policy).
• Contribute to internal technical talks (brown bag, design deep-dive, or demo).

What to expect in the first year:

• Be recognized as a dependable owner of a subsystem (runtime execution, networking, or observability).
• Lead 1 cross-functional feature effort with AI/ML or DevOps teams.
• Deliver at least 3 measurable performance/reliability improvements with demonstrated customer impact.
• Propose and implement a developer experience or CI/CD improvement that reduces engineering friction.
• Contribute to an open-source integration, library, or documentation effort in the Rust/WASM ecosystem.

Perks:

• Freedom & flexibility; fit your work around your life.
• Home Office Setup: We want you to be comfortable while working.
• Training stipend for conferences, courses, and classes.
• Equity: We are a growing start-up, and we want all employees to have a stake in the company's success.
• Cutting-Edge Work: Shape the Future of AI and Infrastructure Software.
• TAHO Swag.
• Medical benefits and holidays.

Skills

List of relevant technical and domain skills for this role

Core Programming & Backend Skills

• Rust (primary language; memory safety, high-performance backend services)
• Go or C++ (secondary backend languages for performance-critical systems)
• WebAssembly (WASM) (execution environments, sandboxed runtimes)
• Microservices architecture (design and optimization)
• Distributed systems (resiliency, scalability, orchestration)

Runtime, Execution & Infrastructure

• Kubernetes (container orchestration, multi-tenant deployments)
• CI/CD pipeline design (automated deployment across cloud and on-prem)
• Dynamic code streaming & live patching
• Observability & monitoring (diagnostics, metrics, runtime analytics)

Networking & Communication Protocols

• Low-latency protocols:
  
  • DDS (Data Distribution Service)
  • gRPC
  • Libp2p
  • Custom P2P communication models
• Zero-trust networking models (secure data exchange across distributed nodes)

Performance Optimization & HPC

• High-performance computing (HPC) environments
• AI/ML inference pipeline optimization
• Reducing cold start times for workloads
• High-throughput data pipelines
• AI-driven runtime optimizations (reducing inference energy consumption, improving efficiency)

Security & Cryptography

• Zero-trust architecture
• Cryptographic verification (signatures, checksums, proofs)
• Container isolation
• Secure enclave execution

Cross-Environment Deployment

• Cloud, edge, and on-prem orchestration
• Multi-cloud strategies
• Scalable runtime deployment across heterogeneous environments

Bonus / Nice-to-Have

• AI/ML workload integration (experience with inference optimization)
• Open-source ecosystem contributions
• Experience with real-time streaming updates
• Strong benchmarking & performance testing frameworks