Role Overview

You will own Exterview’s backend engine, the foundation powering AI-driven interviews, candidate scoring, hybrid assessment flows, and real-time reporting.

Every candidate evaluation, AI-generated insight, skill analysis, and report generation flows through your services. From microservices to data pipelines, you’ll design and build the backbone that enables scalable, intelligent hiring workflows for enterprises worldwide.

This role goes beyond building APIs you will define system contracts, data models, and scalability patterns that allow Exterview to support tens of thousands of concurrent interviews, assessments, and AI-driven processes with sub-100ms latency.

You’ll work closely with FE, AI, Prompt Engineering, and DevOps teams to ensure the platform’s foundation is secure, high-performance, and resilient.

Execution is managed via Linear (sprints), Notion (PRDs), and GitHub (repos), collaborating across teams to make backend design decisions visible, reproducible, and accountable.

Key Responsibilities

Service Architecture & APIs

- Design, implement, and maintain Node.js microservices with clean modular boundaries.

- Expose REST/GraphQL endpoints for FE, AI agents, and internal workflows.

- Ensure robust API contracts with versioning and backward compatibility.

Data Modeling & Schemas

- Define schemas for candidates, interviews, assessments, AI insights, and reports.

- Manage graph-based relationships between candidates, jobs, and interviewers using MongoDB

- Ensure data consistency, scalability, and efficient querying.

Asynchronous Workflows

- Implement Pub/Sub and task queues for long-running jobs (report generation, AI scoring, skill analysis).

- Orchestrate workflows that integrate AI agents, candidate evaluation, and feedback pipelines.

Commercial & Notifications Layer

- Integrate billing, subscriptions, and transactional notifications via Razor Pay and SendGrid.

- Ensure audit compliance, logging, and secure transaction handling.

Performance & Scale

- Optimize backend services for high throughput and low latency.

- Maintain sub-100ms API response times under concurrent interview loads.

- Implement caching and indexing strategies to improve real-time performance.

API Gateway & Security

- Route services securely via AWS API Gateway / Azure API Management with JWT authentication, rate limiting, and role-based access control.

- Ensure secure handling of sensitive candidate data, transcripts, and evaluation reports.

CI/CD & Reliability

- Collaborate with DevOps to maintain GitHub Actions pipelines for testing, containerization, and deployment.

- Write integration, contract, and load tests for regression-free releases.

- Monitor system health using observability tools (OpenTelemetry, CloudWatch, or Azure Monitor) for tracing, metrics, and alerts.

Cross-Team Collaboration

- Work closely with Product Managers, FE, and AI teams to align API contracts and backend capabilities with platform requirements.

- Translate PRDs into technical specifications and ensure backend stability during sprints.

Problem Solving

- Anticipate performance bottlenecks, scaling challenges, and data modeling complexities.

- Propose architectural improvements and maintain a robust, future-proof platform.

Success Metrics

90 Days (Probation):





- Deploy initial microservices to Cloud Run / Azure Functions with API Gateway routing.

- Ship candidate and interview data schemas (MVP).

- Integrate Stripe test billing and SendGrid notifications.

12 Months:

- Scale backend to handle 10K+ concurrent interviews and assessments.

- Maintain 99.9% uptime with zero Sev1 backend-originated outages.

- Optimize p95 API response times <100ms under production load.

- Achieve CI/CD coverage >90% with automated regression tests.

Must-Haves

- 5+ years of backend engineering experience ( Node.js, async frameworks, REST/GraphQL APIs and gRPC).

- Deep expertise in distributed systems, scalable APIs, async I/O, and microservices.

- Hands-on experience with cloud platforms (AWS, Azure, GCP) including compute, databases, and pub/sub services.

- Proven track record delivering high-scale backend systems in production.

Nice-to-Haves

- Experience with Azure, RAG, vector search, Agentic memory.

- Prior work integrating AI pipelines (LLM orchestration, scoring, evaluation).

- Knowledge of event-driven architectures and async workflows.

- Startup or founding engineer experience.

Tech Stack Visibility

- Core Services: Node.js + Async frameworks

- Data: ,MongoDB,Postgres, Firestore, Redis

- Workflows: Pub/Sub, Cloud Tasks, Cloud Workflows

- Auth & Security: Firebase Auth, JWT, API Gateway / API Management

- Commercial Layer: Razor Pay(billing), SendGrid,SES, Twilio (notifications)

- CI/CD: GitHub Actions, Docker, Container Registry

- Observability: OpenTelemetry, Cloud Monitoring & Logging

- Tooling: Linear (execution), Notion (PRDs), GitHub (repos & reviews)

1. Intern-Level Backend Engineering Assessment

Objective

Identify candidates who understand backend fundamentals, basic API and data modeling, asynchronous workflows, and can rapidly learn Exterview's core technologies.

Sections

A. Practical Coding (Node.js)

- Task: Build a REST API in Node.js for basic candidate interview tracking.

- Requirements:
- One endpoint for candidate registration (name, email).

- One endpoint for interview scheduling (candidate, interviewer, date).

- Simulated in-memory data store (array/object).

- Demonstration: Show CRUD operations and query for all upcoming interviews.

B. Data Modeling

- Task: Design (not implement) a MongoDB schema for "Candidate" and "Interview".

- Requirements:
- Define JSON schema for both entities.

- Indicate relationship (reference/interview array).

- Write sample query for fetching all interviews for one candidate.

C. Asynchronous Processing

- Task: Describe how you would handle a long-running report generation task (e.g., AI scoring process).

- Requirements:
- Outline async flow: job enqueue, process, and notify (diagrams welcome).

- Identify advantages of using Pub/Sub or task queue.

D. Security & API Contracts

- Task: Explain how to secure an API endpoint.

- Requirements:
- Discuss JWT authentication basics.

- Note importance of input validation.





E. Collaboration & Documentation

- Task: Write a brief PRD-style note describing a feature you built and how you communicated requirements.

2. Experienced Backend Engineer (6-8 Years) Assessment

Objective

Evaluate advanced skills in scalable backend architecture, distributed systems, cloud infrastructure, security, and technical leadership for senior backend engineering roles across various domains.

Sections

A. System Architecture & Service Design

- Task: Design a microservices architecture for a high-traffic e-commerce platform handling user accounts, product catalog, orders, and payments.

- Requirements
- Define service boundaries and communication patterns (REST/GraphQL/gRPC).

- Address API versioning, backward compatibility, and service discovery.

- Discuss database-per-service pattern and data consistency strategies.

B. Scalable Data Architecture

- Task: Design a data architecture supporting both relational and NoSQL requirements for a multi-tenant SaaS application.

- Requirements
- Choose appropriate databases for different use cases (OLTP vs OLAP).

- Design for horizontal scaling and data partitioning strategies.

- Address cross-database transactions and eventual consistency.

C. Asynchronous Processing & Event-Driven Systems

- Task: Implement an event-driven architecture for order processing involving inventory management, payment processing, and notification systems.

- Requirements
- Design event sourcing and CQRS patterns where appropriate.

- Handle failure scenarios, dead letter queues, and retry mechanisms.

- Ensure exactly-once or at-least-once delivery guarantees.

D. Performance Optimization & Scalability

- Task: Optimize a backend system experiencing performance bottlenecks under high load.

- Requirements
- Identify caching strategies at multiple layers (CDN, application, database).

- Design for horizontal scaling and load balancing.

- Implement monitoring and alerting for performance metrics.

E. Security & Infrastructure

- Task: Secure a multi-service backend architecture deployed on cloud infrastructure.

- Requirements
- Implement authentication, authorization, and secure service-to-service communication.

- Design network security, data encryption, and compliance measures.

- Address container security and secrets management.

F. DevOps & Reliability Engineering

- Task: Design a CI/CD pipeline and deployment strategy for a distributed system.

- Requirements
- Include automated testing strategies (unit, integration, end-to-end).

- Plan blue-green or canary deployment approaches.

- Implement observability with metrics, logging, and distributed tracing.

G. Technical Leadership & Architecture Decisions

- Task: Present a technical decision document for migrating from a monolith to microservices.

- Requirements
- Analyze trade-offs and migration strategies.

- Address team coordination and knowledge transfer.

- Plan for rollback scenarios and risk mitigation.

H. Problem-Solving & System Design

- Task: Design a distributed caching system capable of handling millions of requests per second.

- Requirements
- Address consistency models and cache invalidation strategies.

- Plan for fault tolerance and data replication.

- Consider memory optimization and eviction policies.

📌 Backend Developer (Founding team) (Hyderabad)
🏢 Exterview
📍 Hyderabad