Backend Developer (Founding team)

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

• 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)

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

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

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

• 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 benefits of using Pub/Sub or task queue.

• Task: Explain how to secure an API endpoint.

• Requirements:

  • Discuss JWT authentication basics.

  • Note importance of input validation.

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

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

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

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

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

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

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

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

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

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