We built Hawaii Insurability Brief to answer that call before it becomes urgent.

What the product actually does

Hawaii Insurability Brief is a property lookup tool. You paste in an address (or a TMK — the Hawaii tax map key number), and the tool returns a structured brief on ten hazard and insurability fields for that parcel. Here is what the brief covers:

1. Lava zone. The USGS classifies all land on the Big Island into nine lava flow hazard zones (LHZ 1 being highest risk, LHZ 9 lowest). Zone 1 and 2 properties are uninsurable through the standard voluntary market — period. If you buy LHZ 1 land without knowing it, you own uninsurable land. The brief returns the LHZ for the parcel and a plain-English interpretation.

2. FEMA flood zone designation. Hawaii has several thousand parcels in Special Flood Hazard Areas (SFHAs) across all islands. Zone A and Zone AE properties require flood insurance if there is a federally backed mortgage. Zone V properties — coastal areas subject to wave action — are in a different risk class altogether. The brief returns the FEMA FIRM panel designation, not just “in a flood zone” or “not.”

3. Tsunami evacuation zone. Hawaii has six tsunami evacuation zones, lettered A through F, set by the Hawaii Emergency Management Agency. Zone A is highest risk. Knowing the zone does not directly predict insurability, but it matters for carrier underwriting, for government-backed secondary market eligibility, and for the basic due diligence of buying land in an ocean state.

4. Coastline distance. Raw meters from the parcel centroid to the nearest shoreline. This number shows up in carrier underwriting tables more often than most buyers expect. Many admitted carriers in Hawaii stop writing windstorm coverage within 1,000 feet of the ocean; some stop at 2,500 feet. The number matters.

5. Hurricane wind exposure. Based on parcel geography, island, and elevation. Hawaii is in the Central Pacific hurricane zone. The island chain sits outside the main Atlantic hurricane belt but has absorbed direct hits and near misses — Iniki (1992), Lane (2018), and a list of close calls that make the risk non-theoretical. Wind exposure classification affects the availability and premium of both homeowners and dwelling fire policies.

6. Wildfire risk. Derived from state and federal fire hazard data. The Maui wildfires of August 2023 moved this field from a background concern to the front of every underwriting conversation in Hawaii. Several carriers have restricted or non-renewed Maui County policies since the fires. The brief returns the wildfire risk classification for the parcel.

7. Base Flood Elevation (BFE). For parcels in mapped flood zones, BFE is the FEMA-published elevation (in feet NAVD 88) at which the structure must be elevated to qualify for NFIP coverage. BFE and the actual structure elevation together determine the flood insurance premium — a gap of two feet below BFE can mean a $4,000-per-year premium difference.

8. Shoreline Management Area (SMA) classification. Hawaii’s Coastal Zone Management Act and the SMA permit system govern what can be built, expanded, or rebuilt within the coastal zone. An SMA designation affects not just permitting but the carrier’s perception of rebuild exposure after a storm loss. Some carriers treat SMA properties as construction-restricted, which affects replacement cost underwriting.

9. Roof age estimate. One of the first things a carrier’s underwriter asks about when binding homeowners coverage in Hawaii is the roof: age, material, and condition. A roof over 20 years old is often uninsurable through standard carriers. We pull permit history and satellite-derived roof data to surface the most recent roof permit and a condition estimate. It is an estimate — a physical inspection remains the authoritative source — but for preliminary due diligence it is the right number to have.

10. Carrier availability summary. Which admitted and surplus lines carriers are known to be actively writing in this parcel’s county, lava zone, flood zone, and wind exposure class? This is the most operationally useful field in the brief. It does not replace a quote, but it tells you immediately whether you are looking at a standard-market property, a surplus-lines-only property, or a property where you may be calling five brokers before you find anyone willing to write it at all.

Who this is for

We built it for four groups:

Hawaii homeowners who want to understand what they are buying before they close — or what they already own before their renewal notice arrives.

Real estate buyers — particularly from the mainland — who are encountering Hawaii-specific hazard classifications for the first time and do not have intuitions about what LHZ 2 or Zone AE means in practical terms.

Insurance brokers who spend non-trivial time every week pulling hazard data from FEMA, USGS, and county GIS sources before they can even quote a Hawaii property. A full brief in 30 seconds versus an afternoon of tab-switching is a real productivity gain.

Architects and planners doing preliminary site analysis. Before you invest in a full Phase 1 or engage a structural engineer, knowing the SMA status, BFE, and lava zone of the parcel is useful framing for the conversation.

The freemium model

Three fields — lava zone, FEMA flood zone, and tsunami evacuation zone — are free for any property, no account required. Those three fields answer the binary insurability question for most Hawaii properties: is this land in a zone that will make insurance difficult or impossible?

The full 10-field brief is $19 per property. That is a one-time purchase, not a subscription. For a buyer doing due diligence on a $750,000 property, $19 is a rounding error on their earnest money. For an investor running pre-screening on 15 properties before choosing which ones to make offers on, it is $285 for information that would otherwise take an afternoon to compile.

Brokers who are running five to fifty Hawaii property quotes a week can subscribe at $199 per month for unlimited briefs across all queries. The subscription also unlocks a simple API endpoint — structured JSON output from the same data pipeline — for brokers who want to pull brief data into their own quoting workflows.

Why we built it

The studio works across Hawaii real estate, construction, and permitting. We kept running into the same problem: hazard data for Hawaii properties exists (USGS publishes lava zone maps; FEMA publishes FIRM panels; the state publishes tsunami zone shapefiles), but it lives in five different places, most of which require GIS literacy to use. Nobody had pulled the data together into a single, address-queryable tool that gave a plain-English answer.

We also noticed that the 2023 Maui fires had accelerated a tightening of the Hawaii homeowners insurance market that was already happening — carriers have been non-renewing and restricting Hawaii policies for several years. The gap between “I have an address” and “I know whether this property is insurable and at roughly what cost” was getting wider, not narrower. A tool that closes that gap is useful regardless of the market cycle; in a tightening market it becomes essential.

What this is not

This is a preliminary hazard and insurability lookup. It is not a licensed insurance assessment, not an appraisal, and not legal advice about permit or SMA compliance. The carrier availability field is a market intelligence snapshot, not a quote. The roof age estimate is derived data, not a physical inspection. We say this clearly in the product and we mean it.

The value is in speed and synthesis — getting the right data in front of the right person ten minutes before the conversation rather than two days after.

The tool is live at insurability.ikenagroup.com. The free preview requires no account. If you are a broker who runs Hawaii property lookups regularly and wants to talk about the API or the subscription, the contact is on the site.

Ikena Design & Build is a software studio in Honolulu, Hawaiʻi. We build AI-native tools for Hawaii real estate, construction, and permitting. See the portfolio.

This is the playbook we’ve converged on. None of it is theoretical. All of it is in shipping code.

Where AI lives in a product, and where it doesn’t

The first decision when integrating Claude into a product is which surface the model touches. We have a rule that’s served us well:

Claude lives behind the deterministic path, not in front of it. User intents that have a clear right answer — log in, view a record, save a form, list items — get handled by traditional code. Claude shows up only where the work is inherently ambiguous, generative, or judgment-heavy: writing a project scope from a sketch, summarizing a week of permit activity, drafting a contractor estimate from a LiDAR scan.

This isn’t a purity argument. It’s about user expectations. Users tolerate a 2-second wait when they know the system is thinking. They don’t tolerate it when they pressed “save.” Keeping AI off the deterministic paths preserves the snap of the rest of the product.

The four call patterns we actually use

After eighteen months and roughly 400,000 Claude API calls across our portfolio, we use four distinct integration patterns. Each fits a different latency and reliability profile.

Pattern 1: Inline generative (user is waiting)

Used when the user has explicitly asked Claude to write or think — generating a project scope, writing a weekly summary, drafting an email. Latency budget: 2–8 seconds.

The pattern:

• Single non-streaming call for outputs under ~500 tokens
• Streaming call (server-sent events) for anything longer, so the user sees progress
• Aggressive use of prompt caching on the system prompt and any large context (project history, document base) — typical cache hit rates run 70-95% in production
• Hard timeout at 15 seconds with a fallback message (“Claude is taking longer than usual — try again or refresh”)

The system prompt for inline calls is typically 800–1,500 tokens and includes role definition, output format, and constraints. We cache it. The user-specific context is usually 1,000–4,000 tokens — also cached after the first call of a session.

Pattern 2: Async generative (user moves on)

Used when the work is bigger but the user doesn’t need to watch it happen — generating a contractor’s weekly client report from logs, summarizing a month of permit activity for a Property Brief email, processing a large LiDAR scan into a draft estimate. Latency budget: 30 seconds to 5 minutes.

The pattern:

• Enqueue the job to a Postgres-backed queue (we use a simple jobs table with pg_notify for triggering — no Redis needed for our scale)
• A worker process picks it up, calls Claude with appropriate model selection (Sonnet for most of these, Opus when output quality matters more than cost)
• Results write back to the relevant record
• User gets a real-time notification or sees the result on next page load

Async lets us use higher-quality (slower) models without blocking anyone. We also use this pattern for batch operations — generating 100 Property Brief weekly emails on Tuesday night, for instance.

Pattern 3: Inline classification (user is waiting, but barely)

Used when Claude is making a decision rather than writing prose — categorizing a lead intent, classifying a permit type, deciding which template to apply. Latency budget: 400ms to 1.5 seconds.

The pattern:

• Haiku 4.5 almost always, unless the classification needs Opus-level reasoning (rare)
• Tight system prompt (300–800 tokens) with explicit output format (“Respond with exactly one of: [a, b, c, d]”)
• Use of response_format or structured output when applicable
• Hard timeout at 2 seconds with a deterministic fallback (apply the default template, log the timeout, move on)

The key with classification is keeping the prompt tight and using the smallest model that produces correct output. We benchmark every classification surface against a labeled set of 50–200 real production examples and only ship when accuracy is above 95% for the target class.

Pattern 4: Tool-using agent (background, multi-step)

Used for our most complex flows — the AI scope generator in BlueWave that reads a LiDAR scan, looks up the parcel TMK in hawaii-as-code, checks recent comparable projects, queries the supplier catalog, and produces a draft estimate with line items. Latency budget: 15 seconds to 2 minutes, async.

The pattern:

• Multi-turn loop with Claude calling tools defined via the Anthropic SDK’s tool-use schema
• Tools are thin wrappers over our internal API endpoints — lookup_parcel, get_recent_projects, query_supplier_catalog, calculate_subtotals
• Each tool returns structured JSON
• The loop terminates when Claude says it’s done or when we hit a max-iteration cap (we use 8 — anything more usually means the agent is stuck)
• We always log the full trace for debugging and quality review

Agentic loops are powerful but expensive in tokens. We use them when the work genuinely requires multi-step reasoning and the latency budget allows for it. Otherwise we prefer to do the orchestration in code and use single-shot Claude calls for the reasoning steps.

Prompt caching: the highest-leverage optimization

Anthropic’s prompt caching is the single highest-leverage optimization we’ve made. Most users underestimate it.

Our typical production call looks like:

• System prompt: 1,200 tokens, cached
• User context (project history, document base, etc.): 2,500 tokens, cached
• User input (the actual request): 200 tokens, not cached

Without caching: ~3,900 input tokens per call.

With caching (after the first call of a session): ~200 input tokens billed at full rate, ~3,700 tokens billed at the cached rate (90% discount).

Effective cost reduction: about 80% on input tokens for repeat calls in a session. For products like BlueWave where a user makes 20–50 Claude calls in a session, the savings compound enormously.

The cache TTL is 5 minutes by default and you can extend to 1 hour with the right header. We tune per-product based on session patterns.

Model selection by surface

We don’t use one model for everything. Our typical distribution:

• Haiku 4.5: classification, simple summarization, fast inline operations. Roughly 60% of our call volume.
• Sonnet 4.6: most generative work — scope writing, email drafting, report generation. Roughly 30% of our call volume.
• Opus 4.7: complex reasoning, agentic loops, anything where output quality is the bottleneck. Roughly 10% of our call volume, but a larger share of our cost.

We picked these allocations empirically. For each new surface, we start on Sonnet, then test against Haiku for cost reduction (does accuracy hold?) or against Opus for quality (does the upgrade matter?). About 40% of the surfaces we initially built on Sonnet eventually moved to Haiku once we tightened the prompts.

What we don’t do

A few patterns we explicitly avoid:

No LangChain, no LangGraph, no autogen. Direct SDK calls (@anthropic-ai/sdk on Node, anthropic on Python). Every layer of framework between us and the API is a layer that can break in a new SDK version, a new model release, or a corner case the framework didn’t anticipate. We’ve debugged enough framework issues to prefer the boring direct path.

No LLM-routing layers like OpenRouter or PortKey. We pay Anthropic directly. The reliability and rate-limit transparency of going direct is worth more than the unification of having one bill for multiple providers.

No vector databases for RAG unless we genuinely need them. Most of our “give the AI access to context” needs are served by passing the relevant text directly in the prompt (cached) and letting Claude work with it. Vector DBs add complexity and an extra failure mode. We use them in two places — Property Brief’s recommendation engine and ProBuildCalc’s similar-scan retrieval — and that’s it. The default is “just put the text in the prompt.”

No streaming for outputs under 200 tokens. The streaming overhead exceeds the latency savings for short responses. We benchmark per surface.

Reliability patterns

In production, Claude calls fail. Not often, but predictably. Our standard error handling:

1. Retry on 5xx and 429 with exponential backoff: 3 retries, 1s/2s/4s intervals
2. Retry on overloaded errors with a fallback to a smaller model: if Opus is overloaded, fall through to Sonnet
3. Don’t retry on 4xx other than 429: those are usually our fault (bad prompt, exceeded context window) and retrying won’t help
4. Circuit breaker per surface: if the surface has had 5 failures in the last 60 seconds, briefly degrade (show a “AI temporarily unavailable” message, fall back to non-AI path)
5. Log every call: request, response, latency, token counts, cache hit rate. We use a simple Postgres table with an index on created_at and surface_id. Two months of logs at our volume is ~3GB. Worth every byte.

We learned the value of logging the hard way. The third time you debug a “Claude said something weird” report by trying to reconstruct what the prompt was, you start logging.

Cost in practice

For a working baseline: BlueWave Projects in private beta makes roughly 8,000 Claude calls per month across all tenants. The split is roughly:

• 60% Haiku ($0.80/M input + $4/M output, with cache discount)
• 30% Sonnet ($3/M input + $15/M output, with cache discount)
• 10% Opus ($15/M input + $75/M output, with cache discount)

Monthly Anthropic bill at this volume: about $180. That’s with aggressive caching. Without caching it would be roughly 3x.

By the time BlueWave is at GA with 200 tenants, we project the bill at $3,500–$5,500/month. Still trivial compared to the alternative of hand-rolling these capabilities or running self-hosted models for marginal quality gains.

What we’d tell a founder building their first Claude integration

Three things:

1. Start with a single Claude call in a single surface. Don’t try to AI-everything. Pick the one place where Claude is obviously the right tool — usually a generative task where the user is waiting — and ship that well before extending.

2. Read the Anthropic prompt engineering docs once a quarter. They get updated. The model-specific guidance for Sonnet 4.6 and Opus 4.7 is more current than most third-party tutorials.

3. Cache aggressively, log everything, and benchmark on real data. These three habits will outperform almost any framework choice or architectural pattern.

If you’re building something AI-native and want to walk through your architecture, the studio takes those calls. Bring your current stack, your latency targets, and your first user flow that needs AI. We’ll map it.

Ikena Design & Build is a software studio in Honolulu, Hawaiʻi. We design and build AI-native products on Anthropic Claude — every product in our portfolio runs against the Claude API in production. See the portfolio.

This is not tax advice. It’s an operator-to-operator walkthrough. Get a Hawaii CPA before you make a filing decision, especially once you cross $4M in annual gross receipts (the threshold where Hawaii requires monthly filing) or you start selling to non-Hawaii customers in volume.

The first thing to internalize: GET is not a sales tax

Most US states have a sales tax that the seller collects from the buyer and remits to the state. The seller is essentially a collection agent. The tax is on the buyer.

Hawaii’s General Excise Tax is not that. GET is a tax on the business itself — specifically, on the privilege of doing business in Hawaii. The state taxes your gross income. You are legally allowed to pass the cost through to your customer (and most businesses do), but the tax obligation is yours regardless of whether you collected it from the customer. If you forget to charge GET on a $10,000 SaaS contract, you still owe the state $471. The customer’s invoice not having the line item doesn’t relieve you.

This is the single most important distinction. Founders coming from California or Delaware assume “sales tax” mental models and get surprised the first time the state asks for money they didn’t collect.

The rate, in detail

The GET rate has two components: the state base rate and the county surcharge.

State base rate on retail services (where SaaS lives): 4.0%

County surcharge:

• Honolulu (Oʻahu): 0.5%
• Kauaʻi: 0.5%
• Hawaiʻi Island: 0.5%
• Maui: 0% (no county surcharge as of 2026)

So the combined rate on Oʻahu for retail services is 4.5% — but here’s where the first wrinkle shows up.

If you pass GET through to your customer as a line item on the invoice, the pass-through amount is itself part of your gross income, which means the pass-through is also taxable. To make the customer’s check land on a 4.5% effective rate after the math compounds, Hawaii publishes a maximum visible pass-through rate of 4.712% on Oʻahu (4.166% on Maui, 4.712% on Kauaʻi and the Big Island).

The 4.712% number is the one you’ll see on Hawaii contractor invoices. It exists because the state taxes the tax. Don’t fight it. Just bill it.

Is SaaS taxable in Hawaii? Yes.

Software-as-a-Service is taxable under GET in Hawaii. The state treats subscription software as a service, and services delivered to Hawaii customers fall under the retail-service rate (4% + county surcharge).

This is different from many states that don’t tax SaaS at all. New York, California, Massachusetts, and Florida have specific rules carving out SaaS from sales tax under certain conditions. Hawaii does not have those carve-outs. If you sell a monthly subscription to a Hawaii-based customer, you owe GET on that revenue.

What about a Hawaii-based SaaS selling to a customer in Texas? Generally, that revenue is not subject to Hawaii GET because the service is being consumed outside Hawaii. But “generally” is doing real work in that sentence — Hawaii nexus rules have edges. If your team is in Hawaii and your servers are in Hawaii, the state has a stronger argument that the service originated here. Talk to a CPA before assuming out-of-state revenue is fully exempt.

There is also a use tax on the other side: a Hawaii business that buys services from out-of-state vendors who don’t collect Hawaii GET may owe use tax on those purchases. Cloud infrastructure (AWS, Vultr, Cloudflare), out-of-state SaaS subscriptions, and contractor services from non-Hawaii providers all potentially qualify. Use tax rates mirror GET rates.

The wholesale rate trap (and opportunity)

Hawaii has a reduced 0.5% wholesale rate for certain business-to-business transactions where the buyer will resell the service. This rate is well-known in the construction trades — a licensed prime contractor pays GET on the full project, and their licensed subs can claim the 0.5% wholesale rate on their sub-invoices.

For SaaS, the wholesale rate is harder to qualify for, but not impossible. If your software is sold as a white-label component that another Hawaii business resells to their end customers, you may be able to invoice them at the 0.5% wholesale rate. The trick is that the reseller must be itself a Hawaii GET-registered business and must be reselling the service essentially as-is. A standard B2B SaaS sale where the customer uses your software in their business is not wholesale — they’re the end consumer, even if they’re a business.

Bottom line: most SaaS revenue is at the full retail rate. Don’t get creative with wholesale unless your CPA gives you a written opinion.

Registration: Form BB-1

Every Hawaii business with gross income subject to GET must register. The form is BB-1, filed once when you start operations. It’s available on Hawaii Tax Online (the state’s modern filing portal).

The BB-1 asks for:

• Legal name and tax ID (your EIN for an LLC, or SSN for a sole proprietor)
• Hawaii business address (the LLC’s address on the Articles of Organization)
• NAICS code(s) — for SaaS, 511210 (Software Publishers) is the primary; 541511 (Custom Computer Programming Services) is common as a secondary
• Activities you’ll engage in (multiple permitted)
• Filing frequency election (more on this below)

Registration fee is $20 one-time (covers GET and most other state taxes — you don’t pay separately for each tax type).

You’ll receive a Hawaii Tax ID after registration. That ID goes on every invoice and every return.

Filing frequency: pick this carefully

Hawaii lets you elect a filing frequency at registration, and changing it later requires a separate request.

Annual returns (Form G-49): Allowed if your annual GET liability is under $4,000 (gross income under ~$88,000). One return per year, due April 20.

Quarterly returns (Form G-45): Allowed if your annual GET liability is under $24,000 (gross income under ~$530,000). Due April 20, July 20, October 20, January 20.

Monthly returns (Form G-45): Required if your annual GET liability exceeds $4,000/month or if the state assigns you monthly status. Due the 20th of the following month.

Annual reconciliation (Form G-49): Every business, regardless of frequency, files an annual reconciliation by April 20 each year.

Most founder-stage SaaS businesses start on annual or quarterly. As you grow, you’ll get bumped to monthly. The state will tell you when — don’t try to game it.

What you actually file

Whether you file monthly, quarterly, or annually, the G-45 (periodic) and G-49 (annual reconciliation) forms ask the same basic structure. For a SaaS business, the lines that matter are:

• Column (a) — Gross income: Total subscription revenue invoiced (regardless of whether collected)
• Column (b) — Exemptions/deductions: Out-of-state sales, qualifying wholesale resales, certain other carve-outs
• Column (c) — Taxable income: (a) minus (b)
• Tax rate column: 0.005 for wholesale, 0.04 for state-retail, plus the 0.005 county surcharge if applicable
• Tax due column: Taxable income × rate

For a Honolulu SaaS billing a Hawaii customer $1,000/month with no exemptions:

• Gross income: $1,000
• Deductions: $0
• Taxable income: $1,000
• State tax (4.0%): $40
• County surcharge (0.5%): $5
• Total GET due: $45

If you billed the customer $1,045.00 (passing the tax through), the gross income on next month’s return goes up to $1,045 — and the tax on the $45 pass-through is what makes the 4.712% effective rate exist.

The county surcharge nuance

The county surcharge applies based on where the service is delivered, not where your business is registered. A Honolulu LLC delivering SaaS to a customer in Wailea (Maui) does not owe the 0.5% county surcharge on that revenue — Maui has no county surcharge. The state retail rate (4.0%) still applies.

Most SaaS founders ignore this and just charge their home-county rate to all Hawaii customers. The state has not aggressively enforced the cross-county allocation for digital services, but the rule technically exists. If you bill substantial Maui or Lanai revenue, ask your CPA whether to allocate.

What to actually do, in order

1. Form your Hawaii LLC (or other entity) at the Hawaii Business Express portal. $50 filing fee. Pick a name. Member-managed if you’re solo.
2. Get an EIN from the IRS. Free, online, takes 10 minutes.
3. Register for GET via Form BB-1 at Hawaii Tax Online. $20 one-time fee. List NAICS 511210 as primary.
4. Set up your invoicing to include the GET pass-through. If you use Stripe, configure a tax rate of 4.712% (Oʻahu) named “Hawaii GET” and apply it to Hawaii customers. Out-of-state customers get no tax line.
5. File your first G-45 when due. Even if the answer is $0 (because all your customers are out-of-state in month one), you still file. The state notices when registered businesses miss filings.
6. Bookmark Hawaii Tax Online and set a calendar reminder for the 20th of every applicable month. Late filing penalties are 5% per month with interest.
7. Hire a Hawaii CPA before your first $100K of revenue. They will save you more than they cost, especially around the wholesale rate, multi-state nexus, and S-Corp election timing.

Three traps to avoid

Trap 1: Treating Stripe collections as net. Stripe’s gross transaction amount, including the part Stripe takes as a fee, is part of your gross income. You owe GET on the gross. Don’t compute GET on the net deposit.

Trap 2: Forgetting use tax on cloud bills. Your AWS, Cloudflare, Vultr, and out-of-state SaaS tool bills may carry Hawaii use tax obligations. Most CPAs don’t catch this on first pass. Ask.

Trap 3: The annual G-49 is not the same as the monthly G-45s. You file BOTH. The G-49 is a reconciliation that captures any adjustments and confirms the year’s totals. Skipping the G-49 because “I filed all my G-45s” is a guaranteed audit letter.

A note on visibility

Hawaii is small. The state knows about your business — every LLC filing, every business license, every banking relationship is matched against tax registrations. If you operate a Hawaii LLC and don’t register for GET, the state will find you, usually within 12 to 24 months. The Department of Taxation runs cross-references against the Department of Commerce and Consumer Affairs filings continuously. There is no realistic upside to non-compliance, and the downside (penalties, interest, criminal liability for willful non-filing) is real.

Register, file on time, pass the cost through to customers, and treat GET as the price of doing business in the islands. Most Hawaii founders we know consider it fair. Public infrastructure here is well-maintained, schools are funded, and the state still has the lowest property tax in the country — GET is part of how that balance gets paid for.

Resources

• Hawaii Tax Online (filing portal)
• Hawaii Business Express (LLC formation)
• Department of Taxation — General Excise Tax overview
• Form BB-1 instructions
• GET rate by county (current as of 2026)

If you’re setting up your first Hawaii SaaS and want a 30-minute call to walk through your specific situation, the studio takes those. Bring your projected revenue, your customer mix (in-state vs out-of-state), and your current entity status. We’ll map it together.

Ikena Design & Build is a software studio in Honolulu, Hawaiʻi. We design and build AI-native web products and we operate as a Hawaii S-Corp, so we file the same forms we’re writing about. This is operator perspective, not tax advice — see a Hawaii CPA before filing.

That isn’t a quirky biography. It’s the thesis of the studio.

The standard is the same

Joinery, done well, is uncompromising. A mortise either holds or it doesn’t. Trim is square or it announces itself for thirty years. A floor that wasn’t acclimated cups, and no amount of marketing changes that. The standard for finish carpentry is binary: it passes the test of a fingertip dragged along the seam, or it fails it.

Software, done well, has the same property. A query either returns in 8ms or someone notices. A multi-tenant boundary is either bulletproof or someone reads another tenant’s data. An iOS scan either captures the wall or it doesn’t, and no amount of “shipped fast, will iterate” rhetoric makes a broken scan useful on a jobsite. The standard is the same standard. The substrate is just different.

The trades teach a person to respect the boundary between good enough to pass inspection and good enough to live with for thirty years. Most software people have never had to live with their own work the way a finish carpenter does. The owner of the house comes back in five years and runs a hand along the casing. If your software ages like cheap pine — fine for a quarter, sad after a year — that’s a kind of failure most engineers never internalize, because they’re working on something they’ll never see again.

What the trades teach about scope

A renovation contract has a number on it. You quote the work, you scope it tight, you build to the scope, and you change-order anything that wasn’t in the original drawings. The clients who hire Ikena for renovations didn’t sign up for surprises. The clients who hire Ikena to build software shouldn’t either.

The software industry’s love of “agile scope” — meaning, in practice, we’ll figure out what we’re building as we go — is a luxury the trades don’t get. A contractor who finds termite damage doesn’t pretend it’s part of the original quote. He stops, documents it, sends a change order, gets it signed, then resumes. That’s not bureaucracy; that’s how you stay in business and respect your client’s wallet at the same time.

Discovery — the paid engagement that precedes the build — exists for the same reason a contractor walks the site before quoting the renovation. You don’t know what you’re committing to until you’ve measured. Ikena charges $5,000 to $15,000 for that walk-through, and applies it to the build if the client moves forward. The math is the same math a finish carpenter does on a site visit. The output is just a product spec instead of a punch list.

What the trades teach about ownership

Every house Ikena finished was a house Ikena had to drive past for years afterward. You see your work. You walk inside it on the next job. You hear, second-hand, what the owners said to a guest about the trim. Every project becomes part of your portfolio whether you wanted it to or not.

That posture transfers. The studio doesn’t write disposable software. We don’t ship a Polycam wrapper that we know is fragile and call it MVP. We don’t bolt no-code tools together and hope they don’t get acquired. The default is to build natively — own the data layer, own the auth layer, own the deploy. Because in three years, someone will run a finger along the seam, and you want the seam to still be tight.

What the trades teach about pace

A renovation takes the time it takes. You can’t pour concrete faster than concrete cures. You can’t acclimate hardwood in 48 hours when it needs two weeks. You can hire more bodies and you can stack trades, but past a certain point you’re just rushing a fixed-duration job and producing the kind of work that calls itself out in the first hot summer.

Software has the same constraint and pretends it doesn’t. There is a fixed minimum time to build a multi-tenant SaaS with billing, auth, an admin panel, and a customer-facing portal. You can pay $300K for a “senior team” to build it in eight weeks — and you’ll get eight weeks of work, with eight weeks of corners cut. Or you can pay one operator to build it in twelve weeks and get something that doesn’t embarrass you on the demo.

Ikena ships engagements in six to twelve weeks. Two builds at a time. Not because we’re slow. Because we’re matching the work to the time it actually takes, the way a contractor matches a remodel to the calendar it actually needs.

The pivot

We don’t do construction anymore. The 2026 pivot moved Ikena Design & Build from a design-build renovation practice to a software studio. The brand carried because design and build was always a verb, not a category. We design and build. The substrate now is web products, AI-native systems, multi-tenant SaaS, iOS native apps. The customers are still mostly Hawaii businesses, plus a growing set of mainland and remote engagements where Hawaii expertise is a genuine moat (property data, contractor workflows, GET tax for SaaS, that kind of thing).

What didn’t pivot:

• Discovery is still paid before the build. We learned this from the trades and we’re not unlearning it.
• Two engagements at a time. Care doesn’t scale.
• One operator on every project. You work with the person responsible for every decision.
• Owned stack, end to end. We don’t rent infrastructure we can build.
• Mālama on the work. Kuleana on the relationship. Laulima with the partners we bring in.

Why we think the trades-to-tech direction is rare and good

Most of the software people building software for trades have never been in a trade. Most of the contractors trying to digitize themselves end up adopting whatever SaaS their competitors use, which is whatever SaaS got VC funding in 2019. There’s a vanishingly small overlap — people who’ve actually poured concrete, paid Hawaii GET, written a change order with shaking hands, and can ship production TypeScript.

That overlap is the moat. Not the code. The standard. The operator who knows what it costs to do work right, who has explained a $5K addendum to a homeowner across a kitchen table, who has had to live with their own seams — that operator is rare on both sides of the fence. And the work that operator produces is the work that has a chance of being good in five years.

That’s the studio. Welcome.

Ikena Design & Build is a software studio in Honolulu, Hawaiʻi. We design and build AI-native web products for the trades, real estate, and the people who keep everything moving. Begin a design engagement.

The answer is no, and the reasoning is the most important thing we communicate before a contract gets signed. This is the post that explains why.

The economics of free discovery

The standard agency or software-shop model — free pitch, free spec, free estimate — has a built-in math problem.

Discovery, done well, takes 20 to 60 hours of senior time. Architecting a multi-tenant SaaS, sketching the data model, drafting a stack plan, scoping the build, and writing a real proposal is work. It is not “an hour on a discovery call.” It is multiple full days of an operator’s actual attention.

If you give that work away, you need a high enough conversion rate to absorb the loss on every engagement that doesn’t close. Let’s say discovery is 40 hours at a $150/hour blended rate. That’s $6,000 of unrecovered cost per pitch. If your win rate is 1 in 3, every closed deal has to absorb $18,000 of unsold discovery work. That number bakes into your price quietly, and the clients who do hire you are subsidizing the ones who didn’t.

We don’t want to operate that way. We don’t want our paying clients to pay for the prospects who shopped us and went elsewhere. So we charge for discovery and let the price find the right clients on its own.

What the $5,000 floor buys

The number isn’t arbitrary. It’s the price below which we can’t afford to do the work well.

A $5,000 discovery engagement includes:

• One working session (usually 2–3 hours, in person on Oʻahu or remote) to understand the business, the users, the constraints
• A written product specification — user flows, feature list, edge cases, what’s in and what’s out
• A data model — the tables, the relationships, the indexes
• A stack plan — frontend, backend, data store, AI integration, third-party services, hosting
• A phased build timeline with milestone definitions
• A preliminary build budget with line items
• An AI-integration strategy where applicable (which Claude calls live where, what gets cached, where humans stay in the loop)

That output is yours regardless of whether you build with us. We deliver it as a PDF and a Notion doc, and you can hand it to another developer if you’d rather. The thinking is what we’re charging for. The thinking is real work.

$5,000 is the floor for a simple build — a small SaaS, an internal tool, an iOS app with limited scope. $15,000 is the ceiling for the most complex engagements — multi-tenant platforms, multi-product systems, anything with real ML or significant compliance burden. Most engagements land between $7,500 and $10,000.

The credit

The discovery fee is credited toward the build cost if you proceed. So a $10,000 discovery on a $90,000 build means the build invoice is $80,000, not $90,000. The discovery wasn’t an extra cost — it was the first installment.

This matters because it removes the “I’m paying twice” objection. You’re not. You’re paying once. We just bill the planning portion up front, before the architecture decisions are baked, because we want you to take those decisions seriously and so do we.

If you don’t proceed with the build, the fee is non-refundable. The thinking happened. The output was delivered. Both sides did their part. That’s how professional services work in every other industry — architects, engineers, lawyers, accountants — and we don’t see why software should get special treatment.

What the price filters out

The $5,000 floor isn’t a money-maker. The studio’s actual margin lives in the build phase. But the floor does two things that matter more than the discovery revenue itself.

First, it filters for clients who take the project seriously. If you can’t write a check for $5,000 to start a $100,000 build, the build was never going to happen. The number is small enough that any real founder or operator can clear it. It’s large enough to be a non-trivial decision. That decision is the first signal of commitment. We are not interested in pitching tire-kickers, and the floor saves both sides a lot of time.

Second, it filters for clients who understand professional services. A client who reacts to a paid discovery model by saying “we’d want to see a free proposal first” is telling us something important: they think of software work as a commodity. They are looking for the lowest-cost provider. They will negotiate every line item. They will not respect the architecture decisions when we make them. We are not a fit for those clients, and they are not a fit for us. The floor makes that conversation happen in week one instead of week six.

What this is not

This is not a barrier built to extract money from prospects. It is not a paywall on conversations. We do not charge for first calls, for general questions, for “would Ikena be a fit for X.” Those conversations are free — usually 20 to 30 minutes, via Cal.com, and we do them gladly.

What we charge for is the work. The moment we open a blank doc and start writing your specification, the meter is on. The line is bright and we’re explicit about when we cross it.

The kind of client this works for

The clients who hire us under this model tend to share a few traits:

• They have done at least one paid professional engagement before — with a CPA, a lawyer, an architect, a consultant — and understand how those relationships work
• They have a real business with a real problem, not a pre-product idea looking for free validation
• They are working from an actual budget number, not a hope that someone will work for equity
• They want one operator responsible for the build, not a body shop with shifting account managers
• They want the discovery output to live with them — they’ll use it whether they build with us or not

If those traits describe you, we’re probably a fit. Begin a design engagement.

The kind of client this won’t work for

Equally honestly:

• Pre-product founders who want free validation
• Clients shopping for the cheapest implementation of an already-spec’d build (you don’t need our discovery — go straight to implementation)
• Enterprise procurement processes that won’t allow per-engagement fees outside of MSAs
• Anyone who wants us to compete against another shop in a bake-off

For those, there are other studios that fit better, and we’ll happily point you to a few. We’d rather be honest about fit in week one than discover the mismatch in week six.

The trade we’re making

Charging for discovery means we close fewer deals. The conversion rate is lower than a free-pitch shop would have. We’ve made peace with that. The deals we do close are higher-quality engagements with clients who are bought in, who respect the architecture decisions, and who pay invoices on time. That’s worth more than volume.

This is the same logic a finish carpenter uses when he charges for a site visit. The shop down the street gives free estimates. He gets fewer leads. The leads he gets are serious, the clients are pleasant, the jobs go smoothly, and he’s still in business at year ten. The shop down the street isn’t.

That’s the trade. We made it on purpose.

Ikena Design & Build is a software studio in Honolulu, Hawaiʻi. Discovery engagements begin at $5,000 and are non-refundable. The fee is credited toward the build cost if you proceed. Schedule a free first call or send an inquiry.

We got tired of it. So over a long weekend, we mirrored the entire public-record map of Hawaiʻi into a single TypeScript codebase — every parcel statewide, every building footprint on Oʻahu, every street address. The result lives at maps.ikenagroup.com and is open to anyone.

The numbers

• 384,262 statewide TMK parcels with full polygon geometry, computed area, perimeter, and a deep-link to qPublic.
• 239,458 Honolulu building footprints with real heights (max + base elevation, NGA cross-reference, owner, structure name).
• 204,775 Honolulu address points with TMK, ZIP+4, census tract, geocoded display address.
• 829,361 generated TypeScript files.
• 56,231,679 lines of code.

Sources: the Hawaiʻi Statewide GIS Program and the Honolulu open data hub. Public records, made queryable.

What we built on top

The map at maps.ikenagroup.com is built with MapLibre GL on the front end and a tiny zero-dependency Node server on the back. Four basemaps: dark, light, voyager, satellite. Five toggleable layers: parcels, 3D buildings (auto-tilts to 60° pitch and extrudes every Honolulu structure to its real height), addresses, streets, and live NEXRAD weather radar.

Tools: a measure tool with distance and area, an export-as-PNG button, a fly-through tour of six island highlights, and a voice-control button that listens for “go to Diamond Head” or “Pearl Harbor” and flies you there. A live Waikiki ocean report at the bottom of the sidebar pulls the current tide from NOAA Honolulu Hbr and the wave height + period + direction from NDBC buoy 51202 at Mokapu Point. Bookmarks save to your browser. The URL syncs to the view, so any framing is shareable by link.

Why we built it ourselves

Three reasons.

First, the data was already public. The State of Hawaiʻi pays staff to maintain this data. The City and County of Honolulu maintains it again. The U.S. Census, the USPS, NOAA — all of them publish their feeds for free. Renting access through a property-data SaaS or a permit-data startup just means paying a third party to download what is already yours.

Second, the data layer is the moat. Every other tool we ship — the iOS scanning app, the project portal, the change-order generator, the contractor SaaS — has to know what address you’re standing on, what zone it sits in, who owns the parcel next door. If we rented that layer, we would be one API price-hike or one acquisition away from being broken. We don’t want to be in that position with a real client’s project on the line.

Third, the work is small once the data is local. Once every parcel is a TypeScript file, looking up a property is a static import. Computing the area of a lot is a function call. Drawing a 3D building over satellite imagery is a paint expression instead of a procurement cycle. The map you can browse today was built in three nights, because the data was already on disk and waited to be addressed.

What it costs us

The whole thing runs on the same Vultr instance that serves our other tools. The data refresh is a polite, resumable scrape against the source ArcGIS endpoints — the parcels take about ten minutes quarterly. The repository is one private GitHub repo. There is no recurring cost. There is no per-user fee. There is no SaaS to renew.

We open-sourced the “mirror” pattern because the public records are public. The source is at github.com/portofcams/hawaii-as-code if you want to do this for another state. Connecticut, Vermont, and Alaska all publish similar feeds; the same pattern would work in a weekend.

Try it

Open the map and try the voice button: “go to Diamond Head.” Or type your address into the search bar — if you’re in Honolulu, the autocomplete is reading from all 204,775 of them. Or click any building in downtown to see its real height. Or watch the tide come in at the bottom of the sidebar — that’s NOAA, live.

We use this every day. We hope someone else does too.

Ikena Design & Build is a software studio in Honolulu, Hawaiʻi. We design and build AI-native web products for the trades, real estate, and the people who keep everything moving. Mālama — care for the work and the place.