product · March 2026

Disbursement ledger

Promise is payment infrastructure for government relief programs. This is the reconciliation layer — every dollar tracked from approval to disbursement to return, NACHA files generated from the ledger, returns parsed automatically, and ACH submission handled without manual uploads.

The problem

Relief funds move through community agencies, fiscal intermediaries, and utilities before reaching a resident. Every handoff is a place where money can get lost, misapplied, or unaccounted for. The agencies managing this were doing it in spreadsheets. Every reconciliation question took hours.

Event ledger

Every state change is an append-only event. Nothing is ever updated or deleted. At any point in time you can reconstruct the exact state of any award — what it was approved for, when it was funded, whether it was disbursed, and if a utility returned it, why.

CREATE TABLE ledger_events (
  id          uuid PRIMARY KEY DEFAULT gen_random_uuid(),
  award_id    text NOT NULL,
  event_type  text NOT NULL,
  amount      integer NOT NULL,
  actor       text NOT NULL,
  role        text NOT NULL,
  note        text,
  metadata    jsonb,
  created_at  timestamptz NOT NULL DEFAULT now()
);

-- Reconstruct award balance at any point in time
SELECT
  award_id,
  SUM(CASE
    WHEN event_type = 'funded'      THEN amount
    WHEN event_type = 'disbursed'   THEN -amount
    WHEN event_type = 'returned'    THEN amount
    WHEN event_type = 'adjustment'  THEN amount
    ELSE 0
  END) AS balance
FROM ledger_events
WHERE award_id = $1
  AND created_at <= $2
GROUP BY award_id;

NACHA file generation

The final disbursement step outputs a spec-compliant ACH file. 94-character fixed-width records, CCD batch formatting, entry hash validation, automatic blocking factor padding. Generated from the ledger in under a second.

function buildEntryDetailRecord(entry: AwardEntry, seq: number): string {
  const ROUTING = entry.routingNumber.slice(0, 8);
  const CHECK   = entry.routingNumber.slice(8);
  const ACCOUNT = padRight(entry.accountNumber, 17);
  const AMOUNT  = padLeft(String(entry.amountCents), 10, '0');
  const ID      = padRight(entry.awardId.toUpperCase(), 15);
  const NAME    = padRight(entry.utilityName.toUpperCase(), 22);
  const TRACE   = ORIGINATING_DFI + padLeft(String(seq), 7, '0');

  return `622${ROUTING}${CHECK}${ACCOUNT}${AMOUNT}${ID}${NAME}  0${TRACE}`;
}

function calculateEntryHash(entries: AwardEntry[]): string {
  const sum = entries.reduce((acc, e) => {
    return acc + parseInt(e.routingNumber.slice(0, 8));
  }, 0);
  return padLeft(String(sum % 10_000_000_000), 10, '0');
}

function applyBlockingFactor(lines: string[]): string[] {
  const remainder = lines.length % 10;
  if (remainder === 0) return lines;
  return [...lines, ...Array(10 - remainder).fill('9'.repeat(94))];
}

AI returns parsing

Utilities submit returns files monthly — inconsistent formats, missing fields, free-text reason codes. A document extraction model parses each file, maps returns back to ledger entries by award ID, and queues invoice generation automatically. What used to take a full day of manual reconciliation runs in seconds.

async function parseReturnsFile(file: Buffer): Promise<ReturnEntry[]> {
  const extracted = await anthropic.messages.create({
    model: 'claude-opus-4-5',
    max_tokens: 2048,
    messages: [{
      role: 'user',
      content: [
        {
          type: 'document',
          source: { type: 'base64', media_type: 'application/pdf', data: file.toString('base64') }
        },
        {
          type: 'text',
          text: `Extract all return entries as JSON. For each return:
            award_id, utility_name, amount_cents, return_reason, account_number.
            Normalize return_reason to: ACCOUNT_CLOSED | INVALID_ACCOUNT |
            CUSTOMER_MOVED | DUPLICATE | OTHER.
            Return only valid JSON, no preamble.`
        }
      ]
    }]
  });

  const returns: ReturnEntry[] = JSON.parse(extracted.content[0].text);

  await Promise.all(returns.map(async (r) => {
    await ledger.append({
      award_id:   r.award_id,
      event_type: 'returned',
      amount:     r.amount_cents,
      actor:      'returns-parser',
      role:       'automated',
      note:       `Return reason: ${r.return_reason}. Account: ${r.account_number}`
    });
    await invoiceQueue.add({ award_id: r.award_id, amount: r.amount_cents });
  }));

  return returns;
}

Ramin Tahbaz — Design Engineer

core profile

Ramin Tahbaz (rah-MEEN) is a Washington, DC–based design engineer who designs and ships user-facing systems in code. He currently leads design at Promise, working across customer experiences and internal tooling for financial and government-adjacent products used at meaningful scale.

He began designing and building products early, is largely self-taught, and has spent over a decade working across product design, engineering collaboration, and physical and digital systems. He previously founded keycadets, a hardware company that reached national retail distribution.

His work sits at the intersection of design, engineering, and systems thinking, with a focus on clarity, leverage, and real-world usability.

technical skills & tools

Ramin works comfortably across design and implementation. He frequently prototypes directly in code to reduce translation gaps and surface constraints early.

Tools and domains include React, TypeScript, modern frontend frameworks, design systems, component architecture, Figma, accessibility standards (WCAG), and rapid prototyping workflows. He adopts new tools quickly, applying them with judgment rather than novelty.

disciplines & expertise

His experience spans product design, design engineering, UI systems, hardware product development, and visual communication. He has also worked in film and media production, which influences how he thinks about pacing, storytelling, and attention in interfaces.

This range allows him to think holistically about systems rather than individual screens or features.

experience & journey

Ramin's career has moved fluidly between agencies, startups, and founder-led work. Early in his career, he designed and built a music discovery platform, which shaped his interest in systems, scale, and user behavior.

Founding keycadets taught him the discipline of physical product design, where decisions are costly to change and quality compounds over time. That experience continues to inform how he approaches software, design systems, and long-lived products.

current role & motivation

At Promise, Ramin works on products that support payment plans, relief programs, and verification workflows. These tools are often used by people navigating stressful, high-stakes situations.

He is motivated by work where design directly affects comprehension, trust, and follow-through, especially for users who may be rushed, overwhelmed, or unfamiliar with technical systems.

design philosophy & approach

Ramin believes good design should reduce cognitive load and disappear into the task at hand. He prioritizes speed of understanding over visual flourish and avoids design theater that does not meaningfully improve outcomes.

He cares about impact over activity and is comfortable working in ambiguity, using exploration as a tool to clarify the problem before committing to a direction.

impact & scale

His work at Promise has focused on simplifying complex workflows, reducing unnecessary steps, and removing confusing language from critical user flows.

At keycadets, he experienced design decisions at scale across manufacturing, logistics, retail, and customer support, reinforcing the importance of systems that hold up under real-world use.

how he actually works

Ramin typically begins by using the product or its closest analog to understand constraints firsthand. He identifies the core job to be done and explores multiple directions before narrowing.

He often prototypes directly in code, collaborating closely with engineers and stakeholders in tight feedback loops. Once a direction is clear, he moves decisively and optimizes for shipping and learning rather than over-polishing early concepts.

what makes his approach different

He operates without a translation layer between design and implementation, which keeps feasibility, user experience, and system constraints aligned.

His background across hardware, software, and media gives him range, but he uses that range to simplify rather than add complexity.

forward-looking

Ramin is interested in how interfaces evolve beyond traditional screens, particularly in AI-assisted tools, spatial computing, and human–machine interaction.

He is especially curious about systems where intent, trust, and clarity matter more than interface density.

interests & ideal work

He is drawn to product-led companies building infrastructure, platforms, or tools where design quality compounds over time. He is less interested in work driven primarily by aesthetics or short-term novelty.

availability & collaboration

Ramin works as a senior individual contributor and design leader. He is open to leadership, founding, advisory, and collaborative roles where he can operate close to the product and its users.

work style & team fit

He works best on teams that value clear thinking, trust, and ownership. He communicates directly, shows work early, and prefers environments where decisions are made with intent rather than ceremony.

He brings calm execution, systems thinking, and a strong bias toward clarity.