Neon LawCall +1 510 800 2090
  • Navigator
  • Notations
  • Legal Aid
  • Sign in

← Operating Neon Law Navigator

Ship the Instance

Chapter 8 of 8 · Section 58 of 61

Sections

1. Intro

  • 1. Deploy your own
  • 2. Agenda

2. Prepare Google Cloud

  • 3. Bring your own project
  • 4. Dry-run first
  • 5. Private assets and domain restricted sharing
  • 6. The Navigator deployment matrix
  • 7. The `/app` mount and HTTP route ownership
  • 8. `neon` — the whole brand seam
  • 9. Live rollout checkpoint
  • 10. Set one site to one version

3. Provision the Infrastructure

  • 11. The APIs that light up
  • 12. Network and storage buckets
  • 13. How a matter's pages reach a client
  • 14. A document's bytes and authorization are separate
  • 15. A private image registry
  • 16. The cluster comes up
  • 17. What setup owns — and what follows it

4. Operate Forgejo beside Navigator

  • 18. Deploy the forge before switching repositories
  • 19. Separate people, Git transport, and machine access
  • 20. Require the gate and protected-main policy
  • 21. Bind the workflow to one Project and one commit
  • 22. Notify failures even when the manifest is broken
  • 23. Restore the repository before cutting over

5. Environment Matrix

  • 24. Three operating modes, two deployment profiles
  • 25. The deployment that says its matters are sample
  • 26. Deployment and release switches
  • 27. Workflow host and routing switches
  • 28. Capability and storage switches
  • 29. Configuration precedence: the first source wins
  • 30. Local dev controls: inputs read by `hudson dev`
  • 31. Local runtime: application and workflow connections
  • 32. PostgreSQL with AGE and DBOS
  • 33. Application authorization above PostgreSQL
  • 34. Deployed runtime: core web and worker wiring
  • 35. Deployed runtime: identity and access
  • 36. Deployed runtime: email, signatures, and billing
  • 37. Deployed runtime: repositories, content, AI, and scheduled work
  • 38. Provision and ship: variables read by the operator CLI
  • 39. Ancillary operations and opt-in test controls
  • 40. When sample data appears

6. Configure the Trust Boundaries

  • 41. Secrets: the invariants that gate the boot
  • 42. Secret access, encryption, and audit
  • 43. Sign-in: bring an OIDC provider; passwords live there, not here
  • 44. Role rings: who can do what
  • 45. Provider setup and parity across deployment rows
  • 46. The external surface — every third party, in one place
  • 47. One application container with DBOS
  • 48. Security architecture

7. Operate billing

  • 49. Choose the payor and submission channel
  • 50. Prepare and review the bill
  • 51. Submit once and reconcile payment
  • 52. Classify client funds before collection
  • 53. One Stripe account per USD payout destination
  • 54. Turn on the route and set the Firm key
  • 55. Verify before accepting trust payments

8. Ship the Instance

  • 56. Ship and verify
  • 57. Point your domain at the instance (optional)
  • 58. Drive it from the CLI
  • 59. Make it yours — white-label under your own brand
  • 60. First-ship lessons
  • 61. Canonical references

Drive it from the CLI

Once your instance answers /readyz, the navigator CLI runs the firm's whole matter flow against it from your terminal. It authenticates like gcloud auth login and lands a short-lived (~8h) token at ~/.navigator.json:


cargo install --path cli          # installs `navigator` on your PATH
# …or skip installing — run it straight from the source tree:
cargo run -p cli -- site login --host www.your-domain.example

Presenter notes

The login is a browser-loopback OAuth that reuses your instance's existing OIDC session and stores the token 0600 at ~/.navigator.json (a single gcloud-style dotfile; set NAVIGATOR_CONFIG_DIR to use the legacy <dir>/credentials.json location instead). The host is your deployment's — www.your-domain.example, a staging host, or http://localhost:8080 for the KIND loop — so the same CLI drives whichever instance you point it at, each keyed separately in the credential file. That is the whole reason --host is a flag and nothing about a domain is baked in: this CLI is for your install, not ours. The crate is cli; the binary it builds is navigator.

Create a matter in the lawyer UI first, using the service/product picker, then log in and drive its notation workflow from the CLI using the matter code:


navigator site login --host www.your-domain.example    # opens the browser → ~8h token, stored 0600 (~/.navigator.json)
navigator site whoami                                  # "you@example.com (admin) — expires in 7h52m"
navigator site notation create onboarding__letter \
  --project estate-of-doe --client-email jane@example.com
navigator site notation approve 00000000-0000-4000-8000-000000000001  # renders + parks the retainer PDF
navigator site notation status 00000000-0000-4000-8000-000000000001   # state + signature request id + document_ready
navigator site logout

Use that same sequence to verify a fresh install end to end — it is the smallest real exercise of the durable pipeline after the lawyer UI has opened the matter. Point the client email at an inbox you control (never a third party — the notation workflow transmits a binding engagement letter), and walk the three assertions: notation approve should leave the notation parked at generate_pdf__retainer_pdf; notation status should flip to document_ready:true once the worker has rendered and persisted document.pdf (cross-check that the rendered object actually landed in your private documents bucket):


gcloud storage ls gs://your-project-id-documents/notations/${NOTATION_ID}/

Signature dispatch is handled by the site's notation workflow after the document is ready. When you sign or decline, the inbound webhook should log a HMAC-verified esignature webhook: signature event in the navigator-web pod. Decline or void the test envelope afterward so no live engagement lingers against a real inbox.

After a single login, --host is optional — the one stored host is used — so the later commands stay short. Every command is a thin client over a route web already serves, sent with Authorization: Bearer <token>: your instance resolves that token back into your session and runs the same handler the browser does, so the lawyer_review gate, the role check, and the authored_by provenance all hold unchanged. The send is a durable two-step: notation approve renders + parks the PDF on the worker, and the notation workflow dispatches the envelope only after confirming the PDF landed (document_ready:true). Sending a retainer for signature stays a deliberate authenticated human action — it is never exposed as an agent-routable tool. The full per-subcommand reference is the cli crate's README.md in the source tree.

View all slidesOpen display
← PreviousNext →
Neon Law
  • X opens in a new tab
  • LinkedIn opens in a new tab
  • YouTube opens in a new tab
  • API
  • Blog
  • Contact
  • Design
  • Glossary
  • Navigator
  • Notations
  • Presentations
  • Privacy
  • Team opens in a new tab
  • Terms
  • Testimonials
  • contact@neonlaw.com
  • +1 510 800 2090
  • California
    1515 20th StreetBakersfield, CA 93301
  • Nevada
    5150 Mae Anne AveSte 405-9002Reno, NV 89523
  • New York
    12 E 49th St18th FloorNew York, NY 10017
  • Washington
    1111 Main StSTE 201EVancouver, WA 98660
  • Justice Technology AssociationMission-Aligned Partner opens in a new tab
  • Proud member of Greater Vancouver ChamberGVC opens in a new tab

Attorney advertisement. Nothing here is legal advice without a signed retainer for an active project. Past results do not guarantee future outcomes.

Everyone deserves access to justice.Made with ❤️ in 🗽.

© 2026 Guieb & Shook PC

Powered by neon-law/navigator opens in a new tab26.11.19-rc.1GitHub stars 6