# 25 — OpenHouse Global: Real-Estate Service

**Additional project 1 of 4** · `app/OpenHouseGlobal`, `IOS/TheOne/OpenHouse`
**Stack:** TypeScript/Node service, Cassandra (CQL migrations), systemd, iOS SwiftUI client
**Scope:** 367 files · 29,453 lines · 7 versioned CQL migrations

> **Where this sits.** The clearest example in the tree of **schema-versioned
> data modeling** — seven numbered CQL migrations that read as a product
> evolving under a discipline, which is exactly what a bank wants to see.

---

## Structure

```
app/OpenHouseGlobal/src/
  routes/      HTTP surface
  service/     business logic
  engines/     domain engines
  journey/     the buyer journey state machine
  adapters/    external integrations
  infra/       infrastructure wiring
  middleware/  cross-cutting
  Network/     clients
  types/
migrations/
  0001_offers_and_saved.cql
  0002_journey_foundation.cql
  0003_analyses.cql
  0004_market.cql
  0005_feed_reviews.cql
  0006_tier1_listings.cql
  0007_openhouse_my_properties.cql
```

Deployed as `openhouse-global.service` (systemd), with `certs/`, a
`mail-outbox/`, and a `sync.sh`.

## The migration sequence tells the story

Read the filenames in order and you can reconstruct the product's history:
offers and saved items first, then the **journey foundation** (a buyer's
progression through a purchase is a state machine, and it got its own
migration), then analyses, market data, a review feed, tier-1 listings, and
finally per-user property ownership.

**Numbered, additive, forward-only CQL migrations against Cassandra** is the
correct pattern, and it is the answer to "how do you evolve a schema on a
datastore with no `ALTER TABLE` semantics worth relying on": you add tables and
columns, you never rename what holds data, and you version the sequence.

That rule — *nothing holding data gets renamed* — is stated explicitly
elsewhere in this repository as the P0 rule and is applied here.

## The journey engine

`journey/` models a buyer's path as explicit state rather than as a set of
booleans on a user row. That distinction matters: a state machine can be
audited, replayed, and reasoned about at a step boundary; a bag of flags
cannot. For a mortgage-adjacent or transaction-adjacent product, that is the
difference between a system you can prove correct and one you cannot.

## The iOS client

`IOS/TheOne/OpenHouse` — 57 files, 9,294 lines: `Container / Models / Network /
Service / Views`, following the same layering as every other mode in the app.

## Interview surface this opens

- Forward-only schema migration against Cassandra, and why renames are forbidden
- Modeling a multi-step user journey as a state machine rather than flags
- Denormalization for a query-first datastore: designing tables per access pattern
- Running a Node service under systemd with certificate management