About the role
We’re hiring a Junior to Mid-level Full-Stack TypeScript Engineer (≈1–4 years) to ship features across our AI product: Next.js + React on the frontend, Node.js (Express) on the backend, PostgreSQL/Supabase for data, and a clean separation of concerns. You’ll collaborate with product and design, write well-tested code, and build AI features responsibly using closed- and open-source LLMs.
What you’ll do
- Build end-to-end product slices across frontend (Next.js/React) and backend (Node/Express).
- Design relational schemas in PostgreSQL; leverage Supabase (RLS policies, auth, storage) and Redis for caching/queues.
- Ship accessible, responsive UIs with Tailwind CSS, Radix UI, and shadcn/ui; internationalize with next-intl.
- Implement auth (JWT, bcrypt), real-time features (socket.io), and background jobs (Bull or equivalent).
- Integrate AI features: Call LLMs via OpenAI/Anthropic SDKs (streaming responses, function/tool calling, JSON mode).
- Build basic RAG flows (document ingestion, chunking, embeddings, pgvector, retrieval, re-ranking).
- Implement prompt management (templating, variables, role separation), evals with golden sets, and prompt/version control.
- Add safety/guardrails (rate-limits, content filters, PII redaction, allow/deny lists, safe tool execution).
- Optimize latency/cost (caching, batching, retries/backoff, fallbacks across models/providers).
- Write and maintain tests: Jest (unit/integration), React Testing Library, Supertest (API), Playwright (E2E).
- Ship via Git/GitHub, containers (Docker/Compose), and CI/CD (GitHub Actions preferred).
- Participate in code reviews; propose architectural improvements; keep code modular and maintainable.
- Add lightweight observability (logging, tracing, metrics) and sensible error handling.
Tech stack you’ll use
- Languages: TypeScript (primary), JavaScript (ES6+)
- Frontend: Next.js, React, Tailwind CSS, Radix UI, shadcn/ui, next-intl State/Data-fetching: Zustand, TanStack Query
- Backend: Node.js, Express, JWT (jsonwebtoken), bcryptjs, socket.io, Bull (or similar)
- Data: PostgreSQL (Supabase strongly preferred), pgvector, Redis
- AI: OpenAI/Anthropic SDKs, embeddings, retrieval (Supabase + pgvector), basic agent/tool calling; familiarity with LangChain/LangGraph or equivalent is a plus
- Testing: Playwright (E2E), Jest, React Testing Library, Supertest
- DevOps/Tooling: Docker, Docker Compose, Git/GitHub, npm (bun familiarity a plus), GitHub Actions, feature flags
- Observability (nice): Sentry, OpenTelemetry, Langfuse (or similar)
What success looks like (first 90 days)
- Ship 2–3 meaningful vertical slices with tests and docs.
- Replace ad-hoc logic with modular services and clear API contracts.
- Land one AI-powered feature end-to-end (e.g., RAG-backed assistance or structured tool-calling) with prompt/version management and safe secret handling.
- Improve reliability via targeted test coverage, error budgets, and pragmatic refactors; add basic tracing for slow paths.
You’ll excel here if you have
- Full-stack proficiency: Comfortable moving between React components, API routes, SQL, and infra basics.
- Understanding of AI coding:
- Knows when to use LLMs vs. deterministic code; can design prompts as interfaces and manage them like code (templating, versioning).
- Implements embeddings + vector search (pgvector), retrieval chains, and tool/function calling safely.
- Sets up lightweight evals (golden prompts, regression checks) and telemetry for quality, latency, and cost.
- Applies safety practices (rate limits, timeouts, retries, redaction, input/output validation) and fallbacks across providers.
- Architectural judgment: Defines module boundaries, API contracts, and data models that scale.
- Pragmatism: Balances ideal designs with incremental delivery.
- Quality mindset: Clean code, useful tests, actionable logging, and clear docs.
- Collaboration: Crisp communication, constructive reviews, and end-to-end ownership.
Minimum qualifications
- ≈1–4 years building web apps with TypeScript
- Production experience with Next.js/React and Node/Express
- PostgreSQL proficiency and comfort with Docker/Compose
- Hands-on testing experience (Jest/RTL and at least one of Supertest or Playwright)
Nice to have
- Supabase (auth, storage, RLS, SQL) and Redis in production
- AI SDKs (OpenAI/Anthropic), pgvector and embedding workflows; exposure to LangChain/LangGraph or MCP tools
- Real-time features (socket.io) and background jobs (Bull/Queues)
- Performance profiling (Lighthouse/React Profiler), basic observability (Sentry/OTel/Langfuse)
- i18n with next-intl; CSS-in-JS familiarity
- GitHub Actions, feature flags, and basic cost/latency tuning for AI
How we work
- AI-first: We treat AI features like any other production system—prompt/version control, evals, telemetry, fallbacks, and cost/latency budgets. We encourage AI-assisted dev tools (e.g., Claude Code/Copilot) while keeping security and code review standards high.
- Ownership: Small team, high impact—engineers own features end-to-end, from design to metrics.
- Testing & CI: Tests that matter, fast CI, and automated checks for accessibility, types, and prompts.
- Code review: Fast, respectful, clarity-focused; prefer small PRs and steady delivery.
- Remote-friendly: Async-first collaboration across time zones with clear written communication.
