Skip to content

Software development studio/Manila / Remote

Software
that holds
its shape.

We map the domain, name the system, and build the smallest architecture that will still be true in five years.

01 — Manifesto

Software fails as a pile of features. It holds as a structure.

Named objects. Sharp interfaces. Constraints that outlast the sprint. This is how we develop software — and how we refuse to.

  1. 01

    Structure before features

    A feature is a request. A structure is a decision. We refuse to pile screens onto an unnamed model.

  2. 02

    Name things that exist

    If the business cannot point to it, the code should not either. Language is the first architecture.

  3. 03

    Interfaces are contracts

    Latency, empty states, and failure modes are part of the product — not leftovers for a later sprint.

  4. 04

    Code is a liability

    Until it is the cheapest way to keep a promise. We write less, then we make what remains durable.

  5. 05

    Systems outlive authors

    The next engineer should be able to change it without a séance. Observability is a courtesy to the future.

  6. 06

    Shape is a product choice

    Constraints, grain, and the grain of change. Software that holds its shape can still move.

02 — Systems

Four planes. One system.

We do not start with a stack. We start with the planes a product actually lives on — then we choose tools that keep those planes honest.

What people actually touch

Copy, density, empty states, and the time between intent and result. We treat the surface as a contract with a human, not a skin on a schema.

  • Interaction models
  • Information density
  • Failure and recovery copy

03 — Practice

A grain of work, not a ceremony.

Engagements run twelve to thirty-six weeks. We ship a vertical slice early so the model can be proven against reality — then we grow the system along the grain we found.

  1. 2–4 weeks

    01

    Discover

    Artifacts over opinions. We sit with the real workflow — not the org chart — and write down what the system already believes.

  2. 2–3 weeks

    02

    Model

    Names, invariants, events. If we cannot draw it on one page, we do not understand it yet. The model is the product.

  3. 8–24 weeks

    03

    Build

    Thin vertical slices, production from week two. Interfaces stay small. The architecture earns complexity; it is not gifted it.

  4. Ongoing

    04

    Steward

    SLOs, on-call, the next year of change. We leave a system that a new hire can hold — and a written grain of how it should grow.

04 — Workbench

A studio you can query.

Type help in the kernel. Filter the stack by plane. This is how we keep the work inspectable — including the marketing site.

kernel

v0.9

lattice 0.9 — studio kernel

type `help` to list commands

Stack by plane

  • ReactInterface
  • PostgresData
  • SQLiteData
  • React NativeInterface

05 — Selected work

Systems in production, not decks.

Three engagements. Same grain: name the domain, keep the surface small, leave a system someone else can hold.

  • 2025

    Harbor

    Freight operations

    Replaced a twelve-year spreadsheet spine with a domain model: vessels, berths, windows, exceptions. Dispatchers went from tribal knowledge to a system a new hire can run.

    Exceptions closed 40% faster in the first quarter.

    • TypeScript
    • Postgres
    • Event log
    • React

    Case closed

  • 2024

    Northbank

    Treasury

    A mid-market bank needed a single picture of cash. We modeled positions, not reports. The reports fell out of the model — and stopped disagreeing with each other.

    One source of position truth across four desks.

    • Kotlin
    • Postgres
    • Kafka
    • Next

    Case closed

  • 2025

    Fieldnote

    Scientific capture

    Field biologists were losing observations to camera rolls and group chats. An offline-first capture client, structured at the point of seeing, that syncs when the canopy allows.

    Observations reusable the week they are taken.

    • SQLite
    • Sync protocol
    • React Native

    Case closed

06 — Brief

Tell us the system you need to hold.

Typical engagements run twelve to thirty-six weeks. We reply with a written read of the domain — not a deck of capabilities. If it is not a fit, we will say so.

Fit
Product platforms, internal systems, operational software with a real domain.
Not a fit
Brochure sites, staff augmentation, or “just make an app” without a problem.