About Quipu

Quipu is AI infrastructure for long-term memory, built for enterprises engineering complex systems—automotive, drug development, battery storage, and AI agents. We give every entity a single, audit-grade memory so teams can study cause and effect rather than guess at it.

That means vehicles with component-level traceability and failure prediction, accelerated drug development with fewer risky experiments, battery systems with trusted cell-ageing models, and agents with a shared persona that never resets.

Memory at this scale is an infrastructure problem. Ingestion has to keep up, graph traversals have to stay fast as the graph grows, and nothing can silently disappear. The platform that makes those guarantees real is what you'd own.

Working Model—please read before applying.

This is an on-site role at T-Hub, Hyderabad, on a 6-day working week for the first 9 months. We're building core infrastructure to a hard timeline, and we'd rather be upfront about the commitment than surprise you later. After the initial 9 months, the schedule moves to a standard 5-day week.

The Role A platform engineer who thinks in systems, not just scripts. You won't be handed a fully mature platform—you'll be helping build it, which means being someone who is happy to make decisions, document them, and improve them as we grow.

You'll own the platform our engineers build on: how a service gets created, tested, deployed, observed, and recovered. Every hour you save the backend team compounds, and every failure mode you design out is one nobody has to debug at 2am.

You'll also own the question, "Will this hold under load?" Our services are stateful and streaming—Spring Boot services on Kafka ingestion pipelines, backed by Neo4j, YugabyteDB, and vector stores. Performance problems here don't surface in a unit test. They surface as consumer lag, slow traversals, queues that never drain, and timeouts that cascade—and someone needs to trace the flow, work out which conditions expose the weak points, and test for them deliberately rather than during an incident.

You'll work alongside the tech lead and senior engineers, early enough in their design process to change it. We're hiring for 3–5 years of experience, and the design ownership scales with what you can carry.

Platform and Infrastructure

- Build and maintain our cloud infrastructure as code with Terraform: reusable modules, reviewed changes, managed state, no undocumented console edits
- Define how services run: container images, resource limits, health checks, configuration, and secrets, with Docker on Linux and orchestration on Kubernetes or ECS
- Own environment strategy and parity across dev, staging, and production, so a green staging run actually predicts production
- Operate the stateful layer with care: Kafka, Neo4j, YugabyteDB, and vector stores—provisioning, upgrades, backups, tested restores, and capacity headroom
- Harden the platform: secrets in Vault, access control through Keycloak, network configuration, patching, and cost optimization, with the auditability and data-integrity guarantees our customers depend on

Delivery and Developer Experience

- Own multi-stage CI/CD pipelines end-to-end across our Spring Boot services, Python sidecars,



and Angular frontend—build, test, artifact management, environment promotion, and a rollback path that works when you need it
- Give engineers a paved path: a documented, repeatable way to create a service, add it to CI, deploy it, and see it running, without asking you first
- Build self-service tooling and scripts for the work that currently needs a human: environments, test runs, log access, database snapshots
- Wire quality gates into the pipeline so failures are caught before production, and keep them fast and trustworthy—flaky gates get fixed, not re-run
- Partner with backend engineers in design reviews to spot reliability and scaling risks early and make services easier to run, observe, and recover

Performance and Reliability

- Plan and run load, stress, spike, and soak tests against ingestion and retrieval paths, with realistic workload models rather than synthetic traffic that proves nothing
- Work with backend engineers to map the critical flows, then decide which conditions each one needs to be tested under and where the pass or fail line sits
- Establish and maintain performance baselines for core services, so a regression is a number rather than an opinion, and gate releases on them
- Follow a request or event end to end—API, service, broker, database, storage—and take bottlenecks to root cause wherever in that flow they sit
- Report results in terms engineers and leadership can act on: where the limit is, what breaks first, and what it would cost to raise it
- Build observability worth trusting—metrics, logs, traces, dashboards, and alerting that tell the on-call engineer what broke, who's affected, and where to look next
- Participate in on-call, run incident response, and write blameless postmortems that produce tracked fixes rather than documents nobody reads twice

Must-Have Skills

- 3–5 years in platform, DevOps, SRE, or infrastructure engineering
- Solid hands-on experience with at least one major cloud provider (AWS, GCP, or Azure): networking, IAM, managed compute and data services
- Solid Linux fundamentals—networking, processes, permissions, and real performance troubleshooting. You can work out why a box is slow without guessing
- Production experience with Docker and container orchestration (Kubernetes, EKS/GKE, or ECS): deployments, resource limits, health checks, debugging workloads that won't start or won't stay up
- Infrastructure as Code experience, Terraform preferred, in a repo where more than one person changes infrastructure
- CI/CD (required): has built and maintained multi-stage pipelines end to end (Jenkins, GitHub Actions, GitLab CI, or similar)—build, test, artifact management, promotion, and rollback
- Performance testing (required): has planned and run load or stress tests with k6, JMeter, Locust, or Gatling, and used the results to change something




- Can interpret performance data properly—percentiles rather than averages, saturation and error rates, correlating client-side numbers with server-side metrics
- Can work out what to test and under what conditions: reads a flow end to end, identifies the stages that carry risk, and defines the load, concurrency, and failure conditions that will actually expose them—slow dependencies, partial failures, backlog replay, peak concurrency, sustained load
- Comfortable operating at least one stateful service in production—a database, a broker, or a queue—including backup and restore
- Scripting in Bash, Python, or Go at the level of maintainable tooling, not one-off snippets
- Comfort reading logs, metrics, and traces to find root causes in running services
- Writes things down: runbooks, decision records, postmortems—context that outlives the conversation
- Available to work on-site in Hyderabad, 6 days a week for the first 9 months

Strong Plus

- A track record of designing test scenarios that found something real: reading a system's flow, deciding which conditions matter, and building the tests that expose them
- Operating Kafka in production: consumer lag, rebalances, partitioning, retention
- Database performance: Neo4j and Cypher query tuning, distributed SQL (YugabyteDB, CockroachDB), or vector search (Milvus, pgvector)
- Continuous performance testing in CI, with trend tracking and automated regression gates
- Profiling and tracing tools: async-profiler, JFR, OpenTelemetry, Pyroscope; distributed load generation
- Observability stacks: Prometheus, Grafana, Loki, or the ELK stack
- Progressive delivery: blue/green, canary, or feature-flagged releases with Argo CD or Flux
- Secrets and identity in depth: Vault, Keycloak, SSO, short-lived credential workflows
- Automated API testing wired into pipelines (Postman/Newman, REST Assured, pytest)
- Experience in an audited environment (SOC 2, ISO 27001, HIPAA, PCI DSS, or GDPR-heavy)
- Chaos or resilience testing and DR planning with tested RTO and RPO targets
- FinOps and cost optimization where you've measurably reduced spend
- Having been an early platform hire before, and knowing which shortcuts are survivable

Who You Are

- You ask, "Why is the system shaped this way?" before asking, "What should I build?"
- You'd rather find the limit yourself on a Tuesday than have a customer find it on a Friday
- You treat operational pain as a design problem, not a rota problem
- You debug from first principles and write down what you learn
- You're comfortable with ambiguity and small-team ownership—no hand-holding, no rigid specs
- You communicate trade-offs clearly and can disagree constructively in design discussions

What We Offer

- Direct ownership of core infrastructure on a small team—your work ships and matters immediately
- Problems worth solving: graph traversal at scale, streaming knowledge extraction, bitemporal data, and the operational side of running all three
- The chance to set the standards: tooling, deployment model, performance baselines, and the documentation that outlasts the conversation
- Close mentorship from technical leadership on architecture and systems design

📌 Platform Engineer (Performance & Reliability) (Hyderabad)
🏢 QUIPU
📍 Hyderabad