Full-Stack Engineer

About the role

We're hiring a Junior to Mid-level Full-Stack TypeScript Engineer (≈2–4 years) to ship features across our AI product: + React on the frontend, (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 ) 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 ), 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:
  , React, Tailwind CSS, Radix UI, shadcn/ui, next-intl
  State/Data-fetching:
  Zustand, TanStack Query
• Backend:
  , Express, JWT (jsonwebtoken), bcryptjs, , 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

• ≈2–4 years building web apps with TypeScript
• Production experience with 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 ) 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.