Senior NestJS Developer — Multi-Tenant Platforms & Event-Driven Services

About the Role

Architect and build the backend platforms behind our multi-tenant products — service decomposition, tenant isolation, event-driven communication and the data layer underneath. A senior individual contributor role with genuine architectural ownership: the expectation is that you have taken at least two NestJS systems from design through production and lived with the consequences of those design decisions.

Requirements

Architecture and design

•          Own module and service decomposition in NestJS — bounded contexts, dependency injection strategy, module boundaries, and clean separation of domain logic from framework and transport concerns.

•          Design and enforce the multi-tenant isolation model — tenant resolution, data partitioning (row-level, schema-per-tenant or database-per-tenant), per-tenant configuration, quotas and rate limiting.

•          Make cross-tenant leakage structurally impossible rather than a rule engineers must remember — tenant context propagated through request scope, guards, interceptors and the repository layer.

•          Define API contracts — REST with OpenAPI, GraphQL where it earns its place — including versioning, deprecation policy and backward-compatibility rules.

•          Participate in design review before implementation begins; record decisions as Architecture Decision Records.

•          Set service-level standards for configuration, error taxonomy, logging structure and health checks.

Event-driven and microservices

•          Design event flows on RabbitMQ or Kafka — exchange and topic design, partition keys, consumer groups, ordering and delivery guarantees, and the trade-offs between them.

•          Build consumers that survive reality: idempotency, dead-letter queues, retry with backoff, poison-message handling and replay.

•          Apply transactional outbox, sagas and compensating transactions for consistency across service boundaries; know when eventual consistency is acceptable and when it is not.

•          Version event schemas and evolve them without breaking existing consumers.

•          Instrument cross-service behaviour — correlation IDs, distributed tracing, consumer lag and backlog alerting.

•          Define service boundaries that reflect ownership and change frequency, not organisational convenience.

Data layer

•          Own schema design and migrations in Drizzle ORM — type-safe queries, migration strategy against live data, and review of the SQL actually generated.

•          Query performance — indexing strategy, elimination of N+1 access patterns, pagination, connection pooling and read/write separation where warranted.

•          Transaction boundaries, isolation levels, optimistic concurrency and race-condition handling under concurrent writes.

•          Data lifecycle concerns — archival, soft deletes, audit trails and per-tenant retention obligations.

Engineering quality and enablement

•          Meet the 80% coverage gate with tests that mean something — unit, integration and contract tests, with real dependencies in integration tests rather than mocks all the way down.

•          Review pull requests from mid-level and junior engineers; mentor on NestJS idiom and event-driven failure modes.

•          Partner with DevOps on containerisation, configuration and secret injection, graceful shutdown, readiness and liveness probes, and zero-downtime deployment.

•          Own the production behaviour of your services — service level objectives, structured logging, alerting and on-call participation.

Required Skills
•          Minimum 5 years in backend engineering, of which at least 3 years on NestJS in production with strict TypeScript.

•          At least two NestJS projects where you held architectural responsibility — you shaped the solution, not only delivered features inside someone else’s design.

•          Multi-tenant system design — isolation models, tenant onboarding, per-tenant configuration, and the operational consequences of each approach.

•          Microservices decomposition, inter-service communication patterns, and the distributed failure modes that follow.

•          Production experience with RabbitMQ or Kafka, including behaviour under backlog, redelivery and broker failure.

•          Drizzle ORM — or deep SQL plus another type-safe ORM, with a credible path to Drizzle proficiency quickly.

•          PostgreSQL or MySQL depth — schema design, query plan reading, and migrations executed against live data.

•          Docker, Git discipline, and enough CI familiarity to keep your own pipelines green.

Good to Have
•          Working use of Claude Code or comparable agentic coding tools — including the judgement to review AI-generated code critically rather than merging it on trust.

•          Redis for caching, distributed locking and rate limiting.

•          CQRS and event sourcing where the domain justifies them.

•          Strangler-fig migration of a legacy monolith into services without a big-bang cutover.

•          ClickHouse or another analytical store operating alongside the transactional database.

•          Kubernetes, Helm and observability stacks.

•          Integration with government or enterprise systems and third-party APIs with unreliable availability.

Required Skills

• postgresql or mysql depth — schema design
• query plan reading
• and migrations executed against live data.
• drizzle orm — or deep sql plus another type-safe orm
• with a credible path to drizzle proficiency quickly.
• production experience with rabbitmq or kafka
• including behaviour under backlog
• redelivery and broker failure
• microservices decomposition
• inter-service communication patterns
• and the distributed failure modes that follow.
• nestjs
• typescript
• isolation models
• tenant onboarding
• per-tenant configuration
• and the operational consequences of each approach.