Senior Full Stack Engineer; Team Lead

About Suite Op
Suite Op is a property operations platform built for the modern hospitality operator — managing smart devices, deploying next‑gen guest experiences via web apps, and field teams across large portfolios. We integrate with everything from smart locks to payment processors, and serve operators running thousands of units across short‑term rentals and boutique hotels.

We're a lean, seed‑stage team ($3M+ raised) that ships like a company many times our size. The reason: we build with AI, not just for it. Claude Code, Cursor, and Copilot aren't afterthoughts here — they're core to how we work every day.

We're in the middle of a clean‑room rebuild: migrating from a legacy no‑code platform to a hand‑crafted Type Script monorepo. New database, new API layer, new dashboard, new mobile app — all being built from the ground up, right now. It's the most interesting moment to join.

You'll be an engineer who happens to be exceptionally good at working with AI. Not an ML researcher, not a prompt engineer — a builder. You'll write production code across the full stack while leading a small team of engineers doing the same.

You'll use AI coding tools as force multipliers to ship features, debug issues, and refactor at a pace that wouldn't otherwise be possible. You'll also shape how the team works with AI: workflows, guardrails, and standards that make AI‑assisted development reliable and repeatable, not lottery‑ticket development.

This is a player‑coach role. Most of your time is building. But you're also accountable for the output, growth, and direction of the engineers around you.

• Ship full vertical slices across a Type Script monorepo — schema migration, backend service, frontend component — in a single PR
• 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
• Integrate with the messy real world: property management systems, smart locks, payments, and a high‑frequency telemetry pipeline
• Lead and mentor through code review, architectural guidance, and pairing — and set the quality bar
• Establish AI‑assisted development practices that scale with the team

• 2+ years leading engineers — tech lead, EM, or senior engineer who genuinely owned team output
• 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
• Good architectural judgment — knowing when to build, buy, refactor, or ship as‑is
• Clear written communication. We're async‑first; decisions happen in writing

• Modern full‑stack Type Script framework experience (Nest‑style backends, App‑Router‑style frontends)
• 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

Type Script 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, not infra.

• 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's 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
• Async‑first. Decisions happen in writing so they survive past the meeting

You'd be joining mid‑rebuild — the most interesting moment in the lifecycle. The clean‑room architecture is being laid down right now. You won't inherit a legacy system; you'll build the one that replaces it, and you'll define the patterns every future engineer at the company inherits.