Sr. Full Stack Engineer || AI/ML Engineer

QUIPU is a deep-tech startup building a real-time digital thread engine, a system that captures the complete, queryable history of complex physical and digital systems as a living graph. Every event, relationship, and state change is preserved, linked, and made instantly accessible across time.

We are solving a hard distributed systems problem: how do you model, store, and reason over the evolving state of millions of interconnected entities in real time This is infrastructure-level research engineering.

The team is small. The codebase is ambitious. You will matter here.

THE ROLE

We are looking for a Research Engineer who codes. Not someone learning to code, someone who already codes well and wants to apply that ability to genuinely hard problems.

Your primary domain is the full stack of our platform: the APIs, services, and lightweight interfaces that make the digital thread queryable and useful. But full stack at QUIPU means reasoning about consistency models and data flow, not just wiring endpoints together.

You will prototype ideas that may not ship. You will also ship things that will run in production. That balance is intentional.

WHAT YOU WILL DO

– Design and build backend services that expose the digital thread graph over well-defined APIs – Implement event-driven data pipelines that ingest, transform, and route high-throughput streams – Prototype new approaches to graph traversal, lineage tracking, and temporal queries – Contribute to the distributed messaging and persistence layer, understanding the tradeoffs, not just the config – Build minimal, purposeful frontend interfaces for internal tooling and client-facing query exploration – Read academic literature and translate relevant ideas into working prototypes – Write code that your team can read, extend, and trust in production – Participate in architecture reviews, your opinions are expected and taken seriously

LANGUAGES & TECHNICAL SKILLS

You Must Have — Non-Negotiable – Ability to write production-quality code: tested, readable, reasoning about edge cases not just happy paths – Solid understanding of concurrency — futures, async models, race conditions, back-pressure – Comfort with JVM internals — memory model, GC behaviour, thread scheduling – Working knowledge of distributed systems fundamentals: consistency, ordering, failure modes – Proficiency with the Linux command line, Git, and a real debugging workflow

Strong Advantage – Strong command of Java, Spring Boot or Scala — functional programming, type systems, implicits, effect management – Rust — for performance-critical components and systems programming – Python — for rapid prototyping, ML tooling, and data exploration pipelines – D3 JS/Angular — you will touch the frontend occasionally; you should not be afraid of it

Engineering Mindset — As Important As Language – You think in data structures before you think in frameworks – You can implement a working BFS, consistent hash ring, or CRDT from a description not a tutorial – You understand why something is slow before you optimize it – You read source code of libraries you depend on

THE R&D PROFILE WE ARE LOOKING FOR

This section matters as much as the technical requirements. We have worked with good coders who were poor researchers. We want both.

– You follow a thread. When something does not make sense, you go deeper — not wider. – You are comfortable spending two days on a problem that may produce nothing shippable but teaches you something real – You can read a distributed systems paper and identify what is actually novel versus what is redressed prior work – You write notes, diagrams, and design docs naturally — not because you are told to – You have opinions about tradeoffs and can defend them without being defensive when challenged – You have built something outside of class or a job — a tool, a library, an experiment — because you wanted to understand how it worked

WHAT WE OFFER

– Competitive compensation benchmarked to top-tier Hyderabad tech – Direct access to founders, architecture decisions happen in conversation, not Jira or Linear – Exposure to production distributed systems at a level most engineers do not see before 8+ years – A genuine R&D culture, reading papers, running benchmarks, and throwing away a prototype are all valid uses of your time – Stock options, skin in the game from day one – No bureaucracy. No performance review theatre. Outcomes over optics.

THIS IS NOT THE RIGHT ROLE IF

We would rather you know this upfront.

– You want a well-defined spec before you write the first line – You are uncomfortable saying I do not know in a technical discussion – You measure productivity by tickets closed – You find distributed systems problems frustrating rather than interesting – You want a large team, established processes, and a predictable roadmap