Full-Stack Engineer (Mid-Level)

About the role

Centerity builds a multi-tenant observability and monitoring platform: a fleet of lightweight agents streams metrics, events, and inventory from customer environments into a cloud platform that turns them into live dashboards, health states, and incidents. You'll join a small, senior team as a full-stack engineer working across our TypeScript backend and React front end — owning features end-to-end, from the Kafka consumer that ingests the data to the UI screen that displays it.

• Build and extend features across our NestJS microservices (~20 services: APIs, event processors, gateways) and our React front end.
• Design REST APIs and event-driven flows: publish and consume Kafka events, model data in PostgreSQL (TypeORM), cache and coordinate with Redis, and query time-series data in InfluxDB.
• Build UI screens and flows in React using Radix UI and our internal design-system component library.
• Work within a multi-tenant SaaS architecture: tenant isolation, role-based access control, and JWT-based auth (AWS Cognito) are part of everyday feature work.
• Write tests as part of development (unit and integration — we work test-first on new services) and ship through CI on GitHub Actions.
• Run and debug the full stack locally with Docker Compose; instrument your services with Prometheus metrics and structured logging.
• Collaborate through pull requests with code review, and with product via Jira/Confluence.

• Backend: TypeScript, Node.js, NestJS, REST + Kafka event-driven microservices, gRPC at the edge
• Frontend: React, TypeScript, Radix UI, internal design system, Vite
• Data: PostgreSQL (TypeORM), Redis, InfluxDB (time series), Kafka
• Cloud & infra: AWS (Cognito, KMS, Secrets Manager, Bedrock), Docker Compose, GitHub Actions, Prometheus/Grafana
• Also in the codebase: a Go agent for Windows/Linux endpoints (gRPC + mTLS) — you won't own it, but you'll integrate with it

• 2–5 years of professional software development experience, with production experience in TypeScript/Node.js and React.
• Hands-on experience building and consuming REST APIs, and solid SQL/relational data modeling.
• Comfortable with Docker and working in a multi-service (microservices or modular monolith) codebase.
• You write tests without being asked, and you care whether the thing you shipped actually works in the running system — not just in the unit tests.
• Able to take a feature from a short spec to production with reasonable autonomy, and to ask the right questions when the spec is thin.
• Good written communication — our design docs, reviews, and decisions live in PRs and Confluence.

• You use AI coding assistants (Claude Code, Copilot, Cursor, or similar) as a regular part of your workflow — and you know how to review, test, and take ownership of what they produce.
• Hands-on experience building features on top of LLM APIs (Anthropic/Claude, OpenAI, or AWS Bedrock): prompt design, structured outputs, streaming responses, handling failure modes. Our platform includes an AI assistant service built on AWS Bedrock, and this role contributes to it.
• Bonus: experience with agentic patterns, tool use / function calling, or RAG pipelines.

• Docker and Kubernetes in production — deploying, operating, and debugging containerized services (Helm, ECS/EKS, or similar).
• NestJS specifically (or another decorator/DI-style framework such as Spring or Angular).
• Event-driven systems: Kafka, RabbitMQ, or similar message brokers.
• Time-series data or monitoring/observability domain experience (Prometheus, InfluxDB, Grafana, APM tools).
• Multi-tenant SaaS, authn/authz (OIDC/JWT, RBAC/ABAC), or AWS Cognito.
• Go, gRPC/Protocol Buffers, or systems programming exposure.
• Experience contributing to or consuming a shared component library / design system.

• Real distributed-systems work — event pipelines, multi-tenancy, time-series at scale — not CRUD over a single database.
• End-to-end ownership: you ship the API, the events, and the screen, and see it running against live agent data the same day.
• Small team, senior peers, direct access to architecture decisions.