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 Intern to join our engineering team and contribute to the development of TAHO’s distributed runtime platform. This is not a passive internship; you will build, ship, and own real features in production. You’ll learn how to develop distributed systems, write production-quality Rust code, and optimize real-time performance for modern compute environments. This role is hands-on. You will work closely with Staff and Senior Product Engineers and gain exposure to topics such as WebAssembly execution, runtime orchestration, low-latency communication, decentralized coordination, performance-critical runtime components, and distributed resilience.

The mission of this internship is to develop, learn, and contribute meaningfully to the core systems that power TAHO’s infrastructure while growing your engineering craftsmanship and understanding of large-scale system design.

This role requires a builder’s mindset grounded in curiosity, initiative, and technical rigor. The Product Engineer Intern is expected to learn rapidly while contributing meaningful code that advances TAHO’s core systems. Through mentorship and hands-on execution, interns develop the engineering judgment and craftsmanship that enable long-term impact. The Product Engineer Intern must fluidly switch between:

• Technical execution and learning writing and optimizing Rust code that contributes to runtime reliability, performance, and security, while deepening understanding of distributed system design.
• Collaborative development partnering with senior and staff engineers to design, implement, and iterate on features that align with product and architectural priorities.
• Continuous improvement and ownership by applying feedback, refining processes, and driving measurable gains in code quality, performance, and developer experience as technical confidence grows.

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 the design and implementation of backend services in Rust, focusing on runtime orchestration, distributed execution, and high-performance communication.
• Work on WebAssembly (WASM) execution environments optimized for AI and HPC workloads.
• Implement and refine runtime tools for scheduling, diagnostics, and performance benchmarking.
• Build secure communication layers using modern networking protocols (Libp2p, gRPC, DDS).
• Contribute to automated testing, monitoring, and observability across distributed systems.

Compute & Scalability

• Support design and development of scaling models across heterogeneous environments (cloud, edge, on-prem).
• Implement performance instrumentation and contribute to benchmarking frameworks for runtime efficiency.
• Explore low-latency messaging patterns and decentralized coordination mechanisms.

Performance Optimization & Security

• Identify performance bottlenecks and propose targeted optimizations for latency and throughput.
• Learn and apply best practices in zero-trust networking and secure execution environments.
• Participate in improving runtime fault tolerance, auto-recovery, and load balancing strategies.

Collaborating & Learning

• Pair with senior engineers to co-own small-to-medium projects from design to deployment.
• Participate in code reviews and internal demos, contributing feedback and technical insights.
• Document technical learnings and propose iterative improvements to developer tooling and CI/CD workflows.

Qualifications:

• Currently pursuing or recently completed a Bachelor’s or Master’s degree in Computer Science, Computer Engineering, or related field.
• Strong programming foundation with Rust, Go, or C++ — demonstrated through coursework, open-source contributions, or prior internships.
• Understanding of distributed systems concepts (e.g., concurrency, fault tolerance, message passing).
• Familiarity with WebAssembly, microservices, or container orchestration (Kubernetes) preferred.
• Strong communication skills, collaborative mindset, and passion for learning through building.
• Comfortable working in a remote, async-first environment.

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 3-5 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:

• Co-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 co-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.