Full Stack Developer (Founding team)

Role Overview

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

As our founding Full Stack Developer, you’ll ownend-to-end delivery of features — fromNext.js interfaces and real-time dashboards toNode.js/Express or Python microservices andAzure/AWS workflows. You’ll ensure AI-driven insights, voice/avatar interviews, and agentic automation areexperienced by users in real time, reliably and securely.

You’ll useLinear for execution,Notion for specs, andGitHub for repos, collaborating with FE, BE, AI, Prompt, DevOps, and QA to ship polished, production-ready features atstartup velocity.

Key Responsibilities

End-to-End Feature Delivery

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

Frontend Engineering

• Buildreal-time collaborative dashboards usingNext.js, Tailwind CSS, shadcn/ui.

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

Backend Engineering

• Architectmicroservices (Node.js/Express) with async workflows, secure endpoints, and cleanCosmos DB / Redis schemas.

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

Realtime Integration

• ConnectWebSocket events or Azure SignalR to FE interfaces for smoothAI agent streaming, live interview updates, and collaboration features.

AI Workflows Integration

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

• Render AI insights cleanly in the FE workspace.

Data Modeling

• Define schemas acrossCosmos DB, Redisensuring efficient queries and scalable structures.

Authentication & Security

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

• Ensuresecure candidate data handling and compliance with enterprise standards.

Performance Optimization

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

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

Testing & Reliability

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

Collaboration Across Tools

• Manage tasks inLinear, write clear PRDs inNotion, and maintain GitHub repo hygiene.

Problem Solving

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

Success Metrics

90 Days (Probation):

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

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

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

12 Months:

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

Must-Haves

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

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

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

• Experience inscaling enterprise products with high concurrency.

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

Nice-to-Haves

• Experience withAzure, RAG, vector search, Agentic memory.

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

• Prior work onAI-driven workflows or agentic systems.

• Startup or founding engineer experience.

Tech Stack Visibility

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

Assessment (PoC) (mid-junior level)

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

_______________________________________________________________________________

Assessment (PoC) senior level:

Objective: Validate ability tobuild 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 viaAzure 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%)