What we build

End-to-end systems engineering.

From blank canvas to production infrastructure. We design, build, and operate the software that replaces the glue code, manual work, and off-the-shelf compromises slowing your team down, with a concentrated specialization in real estate and property management.

What we do

Five services, one operator.

Each one is something we run in production, not a capability we list. Most engagements start with one and grow into the next.

01 · Core

Custom Software Development

We build production-grade internal tools, customer portals, data pipelines, and full-stack applications. No templates, no off-the-shelf compromises. Every project starts with what the business actually needs and works backward to the code. The data model comes first, because a bad schema is expensive to unwind later. Apps ship in Docker behind nginx with TLS, on servers you own.

Internal toolsCustomer portals REST & GraphQL APIsData pipelines Reporting dashboardsDocument generation

Shipped: FieldFlow, LoanServ, and HostCart, all running in production today.

02 · AI

AI Automation & Agent Orchestration

We design and deploy LLM-powered workflows that run in production: inbox triage, document processing, decision routing, multi-step agents with real tool access. We specialize in Model Context Protocol (MCP) infrastructure that connects AI to your live business systems. An MCP server turns an API into scoped, typed tools an agent can call. You decide which tools exist, so the agent cannot reach past them. Every call is authorized per tenant, logged, and rate limited.

LLM workflow designMCP server development Autonomous agentsInbox & comms triage Document AIclaude-hub automation

Public code: vin-mcp, rag-mcp, and github-mcp-auth, a multi-tenant OAuth 2.1 gateway.

03 · Property tech

Property Management Technology

Deep integrations across the STR/LTR/MTR property management stack. We extend and connect platforms that do not talk to each other by default, build owner-facing portals, automate financial workflows, and eliminate the manual reconciliation that eats your team's time. Most of the work is in the seams. A booking channel, a trust account, and the ledger each hold a piece of the same dollar, and none of them agree on the date. We match on stable keys, never on amounts.

GuestyDoorLoop BaselaneTurno Airbnb / VRBOOwner portals STR complianceBooking automation

Public code: turno-mcp (49 tools against the Turno v2 API) and hospitable-mcp. See the STR and LTR case studies.

04 · Infrastructure

Business Systems Integration

We build the connective tissue between the SaaS tools you already pay for: API orchestration, event-driven sync, webhook pipelines, and custom middleware that turns siloed tools into a coherent system. Where a platform sends webhooks, we listen and sync on the event. Where it does not, we poll on a schedule and track a cursor. Either way a write carries an idempotency key, so a retry cannot post the same charge twice.

API orchestrationWebhook pipelines QuickBooks OnlineGoogle Workspace DocuSeal / e-signTwilio / SMS n8n automationSelf-hosted MCP

Public code: qbo-mcp, lob-mcp, and n8n-google-signin.

05 · Advisory

Consulting & Technology Strategy

Fractional CTO and systems-design work for teams that need senior technical guidance without a full-time hire. We audit your current stack, identify bottlenecks, map the build-vs-buy decision, and produce a roadmap you can actually execute against. The audit is concrete: which system holds which data, where the API access is, and what each hand-off costs in hours. We also name what you should not build, because a bought tool is often cheaper.

Tech stack auditProcess mapping Build vs buy analysisFractional CTO Implementation roadmapVendor selection

Start with a paid consult at $450/hour, billed in 15-minute increments.

How we work

From brief to production, fast.

We keep the process lean. No discovery theater, no six-week scoping cycles.

01

Brief & scope

One call. We map the problem, define the outcome, and decide what to build first. Scoping doc in 48 hours.

02

Design & architect

System design, data model, integration map. We validate assumptions before writing production code.

03

Build & iterate

Staged delivery in real environments. You see working software early and often, not a big-bang launch.

04

Operate & evolve

We stay engaged. Monitoring, incident response, feature additions as your business changes.

Under the hood

How an integration is actually built.

The word integration hides a lot of decisions. Here is what actually gets built, where it runs, and what happens when a system on the other end misbehaves.

What is inside an MCP server

An MCP server is a thin, typed layer over an API you already pay for. Each tool has a schema: named inputs, checked types, one job. The agent sees that list and nothing else. The Turno v2 API becomes 49 tools in turno-mcp. Adding a tool is a deliberate act, and so is leaving one out.

What per-tenant authorization means

Each client signs in with its own identity over OAuth 2.1 and gets its own token. That token maps to one tenant, and the tenant maps to one set of credentials held on our server. Your keys never reach the agent. Two clients on one server cannot read each other's data, because the lookup happens before the call is made.

Where it runs, and how it is watched

Each server runs in Docker on infrastructure we own, behind nginx with TLS. Calls are rate limited per tenant, so one runaway agent cannot burn an API quota for everyone. Writes are logged with the caller, the arguments, and the result. A deploy is a git pull and a health check, with an automatic rollback if the check fails.

What actually breaks in a property data pipeline

Webhooks arrive twice, out of order, or not at all. A retry with no idempotency key charges a card a second time. A rate-limited call that returns an empty list looks exactly like a day with no bookings, so a naive sync deletes real records. We make every write replayable, key it, and fail loudly rather than quietly.

Before the first call

Questions we get every time.

Short, direct answers, so you can decide whether we are a fit before spending money on a consult.

What does NLMA actually build?

Production software, not prototypes. Internal tools, customer and owner portals, data pipelines, reporting dashboards, and the integration layer connecting systems that were never designed to talk to each other. If it cannot survive a Monday morning with real users on it, we have not finished.

Do you only work in real estate?

No. Real estate and property management is where we go deepest, because we operate in it ourselves and know the failure modes cold. The underlying work, systems integration and AI automation and custom applications, applies to any operation carrying too many disconnected tools. Several products we run are outside real estate entirely.

Who actually writes the code?

Forrest Surprenant founded NLMA in 2018 and leads the engineering. The background behind that, including the federal and commercial systems work that came before NLMA, is published in full on the résumé. You can read it before you call.

What does it cost to work with NLMA?

Advisory time is $450 per hour, billed in 15-minute increments, and you can book it directly. Project work gets scoped and quoted after a first call, because a fixed number produced before anyone has seen your stack is a guess. We will tell you which parts are cheap, which are expensive, and which you should not build at all.

What happens to the code if we stop working together?

You keep it. Full ownership, full source, no per-seat licensing on what we build for you, and no dependency on NLMA to keep it running. That is the point of building instead of renting.

How is this different from hiring a contractor?

A contractor builds what you specify and hands it back. Here the design is the work: we map the data, pick the integration points, and own whether it holds up in production. We also stay on after launch, so monitoring, upgrades, and the API change a vendor ships without warning are ours to handle.

What do the first two weeks look like?

One call to map the problem, then a scoping document within 48 hours naming what gets built and what it depends on. Next is the data model and the integration map: which system owns each field, where the API access is, and what has to be backfilled. Then a first slice ships to a real environment with real data.

Last reviewed: .

Next step

Tell us what you need to build.