Full Stack Developer (Founding team)

You will be the bridge between front-end experience and backend intelligence at Exterview. One moment you’ll be implementing a real-time candidate dashboard with live AI scoring, the next you’ll be optimizing a BE to support thousands of concurrent interviews.

As our founding Full Stack Developer, you’ll own end-to-end delivery of features — from Next.js interfaces and real-time dashboards to Node.js/Express or Python microservices and Azure/AWS workflows. You’ll ensure AI-driven insights, voice/avatar interviews, and agentic automation are experienced by users in real time, reliably and securely.

You’ll use Linear for execution, Notion for specs, and GitHub for repos, collaborating with FE, BE, AI, Prompt, DevOps, and QA to ship polished, production-ready features at startup velocity.

• Own stories from PRD → FE/BE design → shipped feature, ensuring seamless integration between front and back layers.

• Build real-time collaborative dashboards using Next.js, Tailwind CSS, shadcn/ui.

• Implement interactive candidate lists, AI scorecards, waveform rendering for voice interviews, and live avatars.

• Architect microservices (Node.js/Express) with async workflows, secure endpoints, and clean Cosmos DB / Redis schemas.

• Implement GraphQL or REST APIs to serve FE dashboards and AI modules.

• Connect WebSocket events or Azure SignalR to FE interfaces for smooth AI agent streaming, live interview updates, and collaboration features.

• Expose AI outputs (candidate scoring, skill gap analysis, interview transcripts) as APIs.

• Render AI insights cleanly in the FE workspace.

• Define schemas across Cosmos DB, Redis ensuring efficient queries and scalable structures.

• Implement Azure AD / Firebase Auth, JWT validation, and session handling in the FE.

• Ensure secure candidate data handling and compliance with enterprise standards.

• Keep FE interaction latency <200ms, API p95 <100ms.

• Ensure SSR + RSC patterns deliver SEO-ready performance and low-latency dashboards.

• Write E2E tests, schema validation, and contract tests for regression-free deployments.

• Manage tasks in Linear, write clear PRDs in Notion, and maintain GitHub repo hygiene.

• Anticipate scaling issues across FE + BE; propose solutions balancing developer experience and system reliability.

• Deliver one complete end-to-end feature (Candidate → AI Scoring → Skill Gap → Report).

• Deploy microservices → Azure Functions / AWS Lambda with FE integration.

• Dashboard live with real-time scoring, AI insights, and one interactive workflow.

• Handle 10K+ concurrent interviews with <100ms p95 API latency and <200ms FE interaction latency.

• Achieve feature parity with top-tier SaaS dashboards (e.g., Greenhouse, Lever).

• Zero Sev1 issues caused by FS-owned code in two consecutive quarters.

• Test coverage >85% across FE + BE code.

• 8–10+ years full stack experience with React/Next.js (FE) and Node.js(BE).

• Proven ability to ship end-to-end features in production SaaS products.

• Strong grasp of async I/O, distributed systems, and real-time UIs.

• Experience in scaling enterprise products with high concurrency.

• Deep understanding of SSR/CSR hybrids, caching, API design, and GraphQL.

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

• Contributions to open-source frameworks (React, Next.js).

• Prior work on AI-driven workflows or agentic systems.

• Startup or founding engineer experience.

• Frontend: Next.js (App Router), React, TypeScript, Tailwind CSS, shadcn/ui, Zustand, Lucide icons, Framer Motion

• Realtime: WebSockets, Azure SignalR, OT/CRDT frameworks

• Backend: Node.js Async, Azure Functions / AWS Lambda, API Gateway

• Data: Cosmos DB, MongoDB, Redis

• Workflows: Azure Logic Apps / Cloud Tasks / Cloud Workflows

• Auth: Azure AD / Firebase Auth (Google/GitHub OAuth)

• CI/CD: GitHub Actions, Docker, Terraform

• Observability: OpenTelemetry, Azure Monitor / Cloud Trace

• Tools: Linear (execution), Notion (PRDs/specs), GitHub (repos)

Objective:
Validate ability to build and deliver a basic full-stack feature involving simple frontend functionality, a backend API, and clean data rendering. Scope is intentionally simplified to evaluate core full-stack skills without requiring cloud, real-time systems, or distributed architecture knowledge.

Challenge (Candidate PoC):

Candidate Flow:
Frontend:

• Build a simple dashboard where a recruiter sees a list of candidates (mock data).

• When a recruiter selects a candidate, show a details section displaying:

  • Name

  • Skills

  • Experience

• Include a "Generate Score" button on the candidate details view.

Backend:
Implement the following API endpoint:
POST /generate-score
Returns structured static or randomly generated scoring JSON:
{
"overallScore": 72,
"skills": {
"javascript": 75,
"react": 70,
"communication": 80
},
"summary": "Strong fundamentals. Needs improvement in React Hooks."
}

Frontend Rendering:

• Render the returned data as:

  • A score card

  • Progress bars for skill scores

  • A summary section containing the text provided by the API

Mini-App AI Simulation:
Frontend:

• Include a text block that displays generated feedback

• Add "Approve" and "Reject" buttons

Backend:
Implement a second endpoint:
POST /generate-feedback
Returns:
{
"feedback": "Candidate shows strong problem-solving but needs improvement in debugging."
}

Background Workflow (Simplified):

• Save the generated score and feedback to a local JSON file, SQLite database, or MongoDB (candidate's choice)

• No cloud automation tools are required

• Email service integration is not required

Performance Requirements:

• Frontend interactions should remain smooth and responsive

• Backend endpoints should respond within approximately 500ms

Deliverables:

• GitHub repository containing frontend and backend code

• Deployed demo (Vercel optional; local execution acceptable)

• Example database schema (JSON, SQLite, or MongoDB)

• Postman or Thunder Client collection

• Optional: short screen recording walkthrough

Evaluation Criteria:
Architecture and Code Quality (25 percent)

• Clean folder structure

• Clear frontend and backend separation

• Readable, maintainable code

Frontend and Backend Integration and UX (25 percent)

• Correct API call integration

• Clear rendering of score and feedback

• Smooth user interaction flow

Data Handling (20 percent)

• Correct saving of scoring data

• Clean JSON or database schema structure

UI Quality (15 percent)

• Simple, clean user interface

• Effective use of components

Documentation (15 percent)

• README with setup instructions

• API description

• Brief explanation of design decisions

Objective: Validate ability to build and deliver a full-stack feature across FE + BE.

Challenge (Candidate PoC):

• Candidate Flow:

  • FE: Dashboard where recruiter selects a candidate → triggers AI evaluation.

  • BE: /generate-score endpoint returning structured scoring JSON.

  • FE: Render scores and skill gaps as interactive blocks (charts, text, progress bars).

• Mini-App AI Simulation:

  • FE: Code block or feedback snippet with “Approve/Reject” action.

  • BE: /generate-feedback endpoint returning actionable suggestions.

• Background Workflow:

  • Trigger report generation via Azure Logic Apps / Cloud Task.

  • Store in Cosmos DB → send transactional email via SendGrid.

• Performance:

  • FE interaction latency <200ms.

  • BE endpoint p95 <100ms.

Deliverables:

• Deployed demo (Vercel + Azure Functions / AWS Lambda).

• GitHub repo with modular FE + BE code.

• Example schemas for Cosmos DB, MongoDB

• Postman collection for APIs.

• 5-min Loom walkthrough.

Evaluation Criteria:

• Architecture & Code Quality (25%)

• FE/BE Integration & UX (25%)

• Real-time Performance (20%)

• Data Modeling & Workflow Integration (15%)

• Documentation & Testing (15%)