Senior Full Stack Engineer

Role Description

You are an engineer who happens to be exceptionally good at working with AI. Not an ML researcher, not a prompt engineer — a builder. You will spend your days in the codebase, shipping production features across the full stack: a schema migration, the backend service that reads from it, and the typed frontend that renders it, often in a single PR.

You will use AI coding tools as force multipliers — to scaffold, debug, refactor, and ship at a pace that would not otherwise be possible. The work is yours end to end. You own the features you build and their failure modes, from the database row to the screen an operator depends on during a turnover.

This is a senior individual-contributor role with no people management and no direct reports. You will influence the codebase the way the strongest senior engineers do — through the quality of what you ship, sharp code review, and architectural decisions that hold up over time — not by managing a team. The surface area is significant, and you will own a meaningful share of it.

What You'll Do

• Ship full vertical slices across a TypeScript monorepo — schema migration, backend service, frontend component — in a single PR, with end-to-end types holding the slice together.
• Drive the rebuild through its remaining phases, including the web dashboard, admin surface, mobile app, and a public API.
• Build for a multi-region, data-residency-sensitive product from day one — a deliberate architectural commitment, made early because our operators run real operations at scale.
• Integrate with the messy real world: property management systems, smart locks, payments, and a high-frequency telemetry pipeline.
• Raise the quality bar by example — through the code you ship, the reviews you give, and the patterns you leave behind for the next engineer.
• Shape how we work with AI: the workflows, guardrails, and standards that make AI-assisted development reliable and repeatable, not lottery-ticket development.

Qualifications

• 5+ years writing production TypeScript / JavaScript.
• True full-stack range: you can write a schema migration, a backend service, and a typed frontend component in the same afternoon.
• Demonstrated fluency with AI coding tools — you can articulate where they accelerate you and where they quietly mislead you.
• Strong relational database instincts: schema design, migrations, indexes, query plans.
• Sound architectural judgment — knowing when to build, buy, refactor, or ship as-is.
• A high bar for engineering hygiene — an untyped boundary or logic that leaked into a controller should bother you.
• Clear written communication. We are async-first; decisions happen in writing, and you can own a hard call in a thread rather than a meeting.
• Comfort working autonomously and remotely — you organize your own time, unblock yourself, and overlap with the team when it matters.

Nice to Have

• Modern full-stack TypeScript framework experience (Nest-style backends, App-Router-style frontends).
• Offline-first mobile architectures.
• Schema-first stacks with end-to-end type safety.
• High-frequency event pipelines or IoT telemetry.
• Multi-region or data-residency-sensitive systems.
• Vertical SaaS with deep integration surface area.

Our Stack

• TypeScript end to end, in a strict monorepo.
• A modular backend, a modern App-Router web app, an offline-first mobile app, and an edge layer for public-facing surfaces.
• Managed Postgres with row-level security and an ORM that owns the schema.
• Background jobs on a managed queue.
• End-to-end type safety from database row to frontend form, validated by a single shared schema layer.
• We deliberately favor managed platforms over primitives, so the team spends its time on product rather than infrastructure.

How We Work

• Small team, high ownership. You own features end to end, including their failure modes.
• AI-first development, structurally. The codebase is deliberately built for AI comprehension: narrow module boundaries, strict types, schema-first data flow. AI tooling is part of the dev loop, not a side project.
• Types over tests, but tests where it counts. End-to-end type safety catches most bugs at compile time. When we test, it is integration tests against real infrastructure — no mocked databases.
• Real engineering hygiene. No `any`, no silenced warnings, no logic in controllers, no auto-save forms. The rules exist because they keep the codebase legible to humans and agents alike.
• Async-first. Decisions happen in writing so they outlast the meeting, and so strong engineers can do their best work on their own schedule.

Why Now

You would join mid-rebuild, the most consequential moment in the company's lifecycle. The clean-room architecture is being laid down right now. You will not inherit a legacy system; you will help build the one that replaces it — and the product it powers already runs the daily operations of operators managing large portfolios. The patterns you set in the slices you ship — how a migration is structured, how a service is wired, how types flow from the database to the form — become the patterns the next engineer reaches for. This is foundational work, and it carries the kind of influence you earn only by building.