Forward Deployed Engineer

Cassi Home

1d • Hybrid

About The Position

Go where the work is. Sit inside a property-management operating company, learn how they actually run, and build the software that makes Cassi fit their world - then bring what you learned back to the platform.

About Cassi
Cassi is a fast-growing startup building an intelligent home automation platform that enables property managers, service providers, and homeowners to easily maintain and operate a property (and more). We're a small team shipping real product daily - SOC2 compliant, event-driven, and built to scale.

The platform only matters if it lands in the real world. Every operating company and partner we work with has its own messy reality — the accounting system nobody wants to touch, the spreadsheet that's secretly load-bearing, the workflow three people hold in their heads. Closing the gap between what Cassi does and what a given operation needs is its own discipline, and it's the one this role owns.

The Role
We're looking for our founding Forward Deployed Engineer - the person who embeds with an operating company or partner, understands their operation well enough to be dangerous, and ships the integrations, automations, and configuration that turn Cassi from "a platform" into "how they work."

This is a role with two halves, and we mean both of them literally. Half of it is deployment: onboarding a new operating company, mapping their data and their workflows onto the platform, standing up the integrations, and running the rollout until it sticks. The other half is engineering: writing real code against Cassi's APIs and event spine - the connectors, the data pipelines, the bespoke automations - that no configuration screen was ever going to cover.

You'll be the first of your kind here, which means you own the problem space, not a backlog. You'll define how Cassi gets deployed, decide what belongs in a one-off versus what should graduate into the core product, and as we grow, build the function and the team behind it. The best forward-deployed engineers make themselves scalable: the fix you write for one operating company should quietly make the next ten easier.

Requirements

• 5+ years of professional software engineering
• You've built and shipped real systems, owned them in production, and developed judgment about what holds up and what doesn't. Enough seniority to walk into an unfamiliar operation, an unfamiliar codebase, and an unfamiliar integration and make progress the same week.
• TypeScript / Node fluency Cassi is TypeScript end to end. You're comfortable in a Node/Fastify backend, with branded types and strict mode, and you can read and extend a codebase you didn't write without breaking it.
• Integrations and data instinct You've connected messy third-party systems before - REST and webhooks, auth flows that fight you, data that doesn't line up until you make it. You can build an ETL path, run a backfill, and reconcile two systems that disagree, and you sweat the correctness of the numbers because someone's business runs on them.
• AWS and event-driven fundamentals Comfortable operating in a cloud, event-driven system - queues and pub/sub, async processing, the ways distributed things fail. You don't need to be a platform architect, but you should be at home when the work crosses service boundaries.
• Database fluency Comfortable with both NoSQL (DynamoDB) and relational (PostgreSQL). You can model data for the access pattern, not just the entity, and you can figure out someone else's schema fast.
• A genuine customer-facing instinct This is the differentiator for this role. You can sit with an operator who is not technical, translate a vague frustration into a concrete build, scope it honestly, and ship it. You read the room, manage expectations, and know when the right answer is "not yet, and here's why." You treat the people you deploy for as colleagues, not tickets.
• Move fast, ship quality You can take a solution from a whiteboard in someone's office to production in days, not sprints. You handle errors and think about failure modes, especially the ones unique to a live business depending on you. Testing is a first-class citizen. Build for today, architect for tomorrow.
• Comfort with ambiguity and ownership There's no runbook for this role yet - you're writing it. You're happy owning a problem end to end, deciding what "done" means, and being accountable for an outcome rather than a task.
• Bachelor's degree in Computer Science/related field or commensurate experience

Nice To Haves

• Property management, real estate, field service, or another operations-heavy domain — you'll ramp faster if you already know how these businesses hurt
• Frontend / full-stack range (Svelte or similar) so you can ship a customer-facing surface, not just backend glue, when a deployment needs one
• Experience as a forward-deployed / solutions / implementation engineer, or a founding engineer who owned customers directly
• Accounting or ERP integration experience (QuickBooks, Sage, Xero, and friends)
• IoT or hardware-adjacent integration work
• Multi-tenant SaaS architecture
• SOC2 awareness, or experience handling customer data responsibly
• Experience at a small company where you owned features — and customers — end to end
• You've been the first or founding person in a function and built the team behind you
• Is a strong team player – you have the skills to communicate your vision to teammates and support others in those pursuits
• Is a capable strategic partner – you are quick to comprehend business and product context, allowing you to contribute to what we're doing and why, with the ability to recognize and fill in the gaps as needed
• Can build trust with people whose business depends on your software — and can say "here's what I can do by Friday, and here's what I can't" without overpromising
• Is highly self-motivated and can own projects end-to-end
• Has the ability to write thorough, scalable and clear documentation
• Is inquisitive nature, can dive into inconsistencies and pinpoint issues

Responsibilities

• Take a new operating company or partner from signed to running. Map their org, their properties, their people, and their existing systems onto Cassi. Own the rollout end to end - including the unglamorous part where their old process and the new one run side by side until trust is earned and the old one can be turned off.
• Connect Cassi to the systems an operation already lives in - accounting, property-management software, IoT, service-provider tooling. You'll own the connectors, the data model that maps their world to ours, the backfills and reconciliations, and the honest answer to "does the number in Cassi match the number in their system." This is where most of the real engineering lives.
• Build on top of Cassi's APIs and event-driven spine to solve a specific operation's specific problem - the automation that fires off a real-world signal, the report that only makes sense for one partner, the workflow the product doesn't cover yet. You'll write code that ships this week and someone depends on next week.
• You're the closest engineer to how Cassi actually gets used, which makes you the sharpest source of what the product should become. You'll tell the difference between a genuinely bespoke need and the third sign of a missing platform feature, and you'll make the case - with evidence from real deployments - for pulling the recurring ones into the core.
• When something breaks for an operator, it breaks their day, not a test. You'll debug across the seam between Cassi and their systems, hold the line on data integrity for a live business, and be the person an operating company trusts to make it right. New user-visible surfaces ship dark behind feature gates, so you'll be comfortable separating deploy from release.

What This Job Offers

• Job Type: Full-time
• Career Level: Senior