Senior Back End Developer

About the Role We are hiring a senior backend engineer to take ownership of the backend across two AI-native products. Both still pre-launch. Platypus is a consulting platform with an NBED multi-agent AI assistant. Quarus is a multi-tenant 3D data visualization platform with an in-app AI analyst. Both products share a common backbone: Python/Fast API Async SQL Alchemy on Postgres SQL Redis Back Server Send Event for real-time updates Auth0 Multi Tenancy Cloud-based agent system built on PyTantic AI Quarus, add a Polyglot dimension, a Go Compute service behind Connect RPC protobuf and a temporal orchestrated data pipeline. You'll be an end senior IC on a small fast-moving team where AI coding agent, Claude code, and autonomous agent committer are part of the daily workflow. You'll direct them, review their output, and help evolve how we use them. What You'll Do Own backend architecture, delivery, and operations across both products — from API design through database schema, migrations, and production deployment. Design and extend LLM agent systems: tool-calling agents, agent routing and handoff, conversation memory and summarization, RAG pipelines, and structured-output classification. Keep AI features safe and economical: prompt-injection hardening, per-tenant ownership guards in agent tools, token/cost accounting, and rate limits that bound paid-call fan-out. Build and maintain real-time streaming infrastructure: SSE endpoints with Redis pub/sub fan-out, designed for horizontal scale and multi-client consistency. Evolve multi-tenant authorization: Auth0 (JWT/JWKS, Organizations), role- and scope-based access control, and tenant-isolation correctness (including IDOR prevention). Own durable data pipelines: Temporal workflows for ingestion and processing, plus the Go compute service they call into. Run the platform: Docker-based environments, Kubernetes (Kustomize) and droplet deployments on DigitalOcean, Terraform, GitHub Actions CI/CD, and SOPS-encrypted secrets. Uphold a strong quality bar: extensive pytest suites (unit + integration, high coverage thresholds), strict typing (mypy), ruff, and documentation kept current alongside the code. Core Tech You'll Work With Languages: Python 3.11+ (primary), Go (compute service), TypeScript (shared contracts; frontend collaboration) Frameworks: FastAPI, SQLAlchemy 2.0 (async) + asyncpg, Alembic, Pydantic v2, Pydantic AI AI/LLM: Anthropic Claude (Sonnet + Haiku), tool-calling agents, RAG with pgvector and OpenAI embeddings, prompt engineering, token-cost auditing Data: PostgreSQL 16 (pgvector, JSONB), Redis, S3-compatible object storage Workflows & RPC: Temporal, Connect RPC / gRPC, Protobuf (buf codegen across Go/TypeScript/Python) Real-time: Server-Sent Events with Redis pub/sub fan-out Auth: Auth0 (RS256 JWT, JWKS, Organizations, Management API), scope-based RBAC Infra: Docker Compose, Traefik, Kubernetes (Kustomize) on DigitalOcean, Terraform, GitHub Actions, Cloudflare Workers, SOPS + age, just Testing: pytest + pytest-asyncio, factory-boy, respx/moto, Vitest (frontend), strict mypy + ruff What We're Looking For Required: 7+ years of backend engineering experience, with at least 3 years building production Python services (FastAPI or similar async frameworks; deep comfort with asyncio). Hands-on experience building LLM-powered product features — not just calling an API, but designing agent systems: tool calling, multi-agent orchestration or routing, conversation memory, structured outputs, and evaluation of model behavior. Daily fluency with AI development tools — Claude Code, Cursor, Copilot, or similar. You should be comfortable directing coding agents, reviewing their output critically, and working in a codebase where agents are first-class contributors (CLAUDE.md/AGENT.md conventions, agent-run CI). Strong relational database skills: schema design, migrations, query performance, and PostgreSQL specifics (JSONB, indexing; pgvector a plus). Experience designing and operating multi-tenant SaaS: tenant isolation, RBAC, JWT-based auth (Auth0, Okta, or similar). Production DevOps ownership: Docker, Kubernetes, CI/CD pipelines, infrastructure-as-code, and comfort being on the hook for what you ship. Strong written communication — our docs, runbooks, and agent-facing instructions are part of the product. Strongly preferred: Go experience, especially for numerical or RPC services. Temporal (or comparable durable-workflow engines like Cadence/Step Functions). Real-time systems: SSE or WebSockets, pub/sub fan-out, optimistic UI reconciliation, concurrency-safe state updates. RAG systems: document parsing/chunking, embeddings, vector search. LLM security awareness: prompt-injection defenses, cost-DoS bounds, sanitizing untrusted data at the model boundary. Protobuf/gRPC contract design across languages. Nice to have: DigitalOcean, Cloudflare Workers, or Terraform Cloud experience. Experience on small teams or early-stage products where you've owned whole systems end to end. Familiarity with report generation (PDF/DOCX), document processing, or data-ingestion pipelines. How We Work Small senior team, high trust, high ownership — you'll ship to production in your first weeks. AI-augmented by default: coding agents open PRs, CI runs agents, and every package carries agent-facing documentation. We expect you to make the agents better, not just tolerate them. Quality is non-negotiable: strict typing, high test coverage, conventional commits, signed commits, squash-merge, and docs updated in the same PR as the code. Everything is reproducible: encrypted secrets in the repo, one-command local environments, infrastructure in code. Compensation & Benefits Competitive, commensurate with experience. How to Apply Send your resume/LinkedIn and — ideally — a short note about an LLM-powered feature or agent system you've built and what you learned shipping it, to [email protected].

Own the backend architecture, delivery, and operations for two AI-native products, including API design and database schema. Design and extend LLM agent systems, RAG pipelines, and real-time streaming infrastructure using SSE and Redis.

Requires 7+ years of backend experience with at least 3 years of production Python/asyncio and hands-on experience building LLM-powered agent systems. Must be proficient with relational databases, multi-tenant SaaS architecture, and production DevOps tools like Kubernetes and Docker.

• KubernetesSouhaitée
• GoSouhaitée
• RedisSouhaitée
• PostgreSQLSouhaitée
• DockerSouhaitée
• TerraformSouhaitée
• PythonSouhaitée

Relevées dans la description du poste. Confirmez les exigences importantes ci-dessus.

• Python
• FastAPI
• Go
• PostgreSQL
• LLM Agent Systems
• RAG Pipelines
• Temporal
• Kubernetes
• Docker
• Auth0
• Redis
• SQLAlchemy
• Connect RPC
• Terraform
• GitHub Actions
• Pytest

• Software
• Technology
• Engineering
• Data & Analytics
• Consulting

Expérience minimale

5+ ans

Langue de l’offre

anglais

Heures de travail

40 heures par semaine

Niveau d’expérience

Mid-Senior level

Mode de candidature

La candidature directe est offerte