Back End Developer

Delhi, India

Backend Engineer JD | Product Engineering

If interested, share resume at - neeti@qikhire.in

About the firm

Firm is an early-stage startup, backed by top-tier VCs, on a mission to 10–100× the productivity of SAP implementation and migration teams.

Why Is This Role Special?

Real enterprise scale: Your backend services will run inside Fortune 500 SAP landscapes — touching live finance and supply-chain data for some of India's and the world's largest companies.
Green-field AI: Build LLM-powered microservices, RAG pipelines, and agentic orchestration layers from scratch — no inherited tech debt.
Proven delivery velocity: The team shipped 8 production SAP APIs in 15 days (vs. a 60-day industry standard). You will operate at that pace.
Founder proximity: Work directly with the founders and own your domain end-to-end.
End-to-end ownership: Schema design, API contracts, observability, Kubernetes deploys — you are accountable for the full stack below the UI.

CRITICAL / SCALE MINDSET IS REQUIRED

We build systems that plug into live SAP environments at Fortune 500 companies. A slow query, a poorly chosen index, or an unthrottled async job can cascade into real business disruption.

This role is open to freshers, but you must understand why scale matters. Being able to reason about indexing trade-offs, async job design, and connection pool limits — even from coursework, personal projects, or internships — is the baseline we hire from. If you have shipped something real (a side project, an intern feature, an open-source contribution), that is a strong signal.

Must-Have Qualifications

Academic & Experience Bar

B.Tech./B.S. in Computer Science from IITs / BITS / NITs / DTU or equivalent top-tier institution.
Fresher to 1 year of hands-on backend engineering experience. Internship projects, academic

projects, or personal/open-source deployments count — we care about what you built, not the

years on your resume.

Strong CS fundamentals: you understand indexing, caching, and async patterns — and can discuss why they matter when systems operate at enterprise scale.

Languages & Frameworks

Proficiency in any one backend language — Node.js, Python, Java, Go, or equivalent — written

idiomatically and used in a production context.

Strong grasp of REST API design: versioning, idempotency, rate-limiting, pagination, backward

compatibility, and contract-first design (OpenAPI).

Microservices architecture: service decomposition, inter-service communication patterns (sync vs. async), circuit breakers, and graceful degradation.

Databases — Deep, Proven Experience Required

Relational (PostgreSQL / MySQL): schema design for scale, index strategy (B-tree vs. GIN vs.

partial), query plan analysis (EXPLAIN ANALYZE), partitioning, read replicas, and connection pooling (PgBouncer or equivalent).

NoSQL (MongoDB / Redis / DynamoDB): document modelling, sharding, TTL, eviction policies,

replication lag awareness, and knowing when NOT to use NoSQL.

Vector databases (pgvector, Pinecone, Weaviate, or Qdrant): embedding storage, ANN search

tuning, HNSW vs. IVF trade-offs — mandatory for our RAG agent pipelines.

You must be able to write, read, and optimise raw SQL. ORM is a convenience, not a crutch; you understand what it emits.

Nice-to-Have

LLM / AI integration: LangChain, LlamaIndex, OpenAI API, Hugging Face Inference Endpoints, or Anthropic Claude API — building production-grade AI agent pipelines, not just calling chat

endpoints.

RAG pipeline design: chunking strategies, embedding model selection, retrieval re-ranking, hybrid search, and hallucination-mitigation at production scale.
SAP ecosystem: OData v4, CDS views, BTP services, RFC/BAPI invocation from external systems, or ABAP enough to read what you are integrating with.
MCP (Model Context Protocol): experience building or consuming MCP servers to expose tools, resources, and prompts to AI agents — enabling standardised agent-to-system integration.
A2A (Agent-to-Agent) protocol: familiarity with multi-agent orchestration patterns where

specialised agents communicate, delegate tasks, and coordinate workflows autonomously.

Infrastructure & async systems: message queues (Kafka, RabbitMQ, SQS), containerisation (Docker/ Kubernetes), cloud platforms (AWS), and CI/CD pipeline authoring.
MLOps: Weights & Biases, MLflow, or model serving (Triton / vLLM).
Open-source contributions, a production side project, or a well-architected academic/internship project you can discuss in depth.

What Will You Do?

% Time Responsibility

50%

Design and build production-grade AI-driven backend microservices (Node.js/TypeScript or

Java) powering SAP workflow automations — covering schema design, API contracts, caching

strategy, connection pooling, and async processing at enterprise scale.

20%

Integrate with SAP ecosystems (OData, CDS views, BTP, RFC/BAPI, S/4HANA APIs) and package

agent capabilities as versioned, reusable SDKs consumed by multiple client delivery projects.

15%

Own observability and reliability: wire up OpenTelemetry tracing, Prometheus metrics, Grafana

dashboards, alerting rules, and automated regression suites that catch performance regressions

before production.

15%

Collaborate with Product, SAP consultants, and Customer Success to convert PoC insights into

shippable features with clean contracts, architectural decision records, and thorough runbooks.

What the Interview Tests

We evaluate candidates on four dimensions — all at production scale, not toy problems:

System Design: Given a real scenario (e.g., a multi-tenant RAG pipeline for SAP document

retrieval), design the database schema, API layer, caching strategy, and async flow. You will be

expected to discuss trade-offs at scale, not just draw boxes.

Database & Query Depth: Live SQL optimisation exercise — EXPLAIN ANALYZE a slow query,

propose index changes, and discuss the trade-offs of your approach.

Backend Coding: Implement a microservice component with proper error handling, test coverage,

and observability hooks — in Node.js or Java, your choice.

Production Experience: Walk us through the most complex system or project you have built (work, internship, academic, or personal): the scale it operated at or was designed for, a challenge you hit, and what you would redesign today.

What Success Looks Like in 6 Months

Shipped at least 3 production-grade backend services with full test coverage, observability, and zero P0 incidents in the first month post-launch.
Independently designed and optimised database schemas (relational + vector) serving sub-100ms p99 query latency under real customer load.
Owned a SAP integration SDK adopted by at least two active client delivery projects
Helped land or expand a marquee customer by demoing live AI-driven SAP features in a real

S/4HANA environment.

Benefits & Perks

Competitive cash compensation + meaningful early-employee equity in a VC-backed pre-growth startup.
Learning budget for courses, certifications, conferences, and hardware — we invest in engineers who invest in themselves.
Flexible hours, generous PTO, and a culture that values deep work and engineering craft over

busywork and meetings.

Work on problems that matter — your code will run at enterprise scale and directly accelerate how India's largest companies modernise their SAP landscapes.

Score my resume against this job, free →