Lambda Functions

Validates AWS SigV4 signatures

Extracts user context from authorizer

Routes: GET /{user_id}/float_check, /{user_id}/underwriting/eligibility, /{user_id}/underwriting/loan/check

Retrieves cached evaluations from DynamoDB

Applies bypass logic for data quality issues

Returns approval status with amounts and reasons

Route: POST /{user_id}/underwriting/instant

Invokes Rule Runner and Result Runner Lambdas synchronously (RequestResponse mode)

Returns a fresh evaluation result in a single request without async polling

Intended for signup and reactivation flows where data is known to be available

Routes: GET/POST /{user_id}/underwriting/profile, GET/POST /{user_id}/floats/temporary_profile

CRUD operations for float profiles

Temporary profile creation with TTL

Routes: GET /{user_id}/underwriting/history, GET /{user_id}/underwriting/history/{evaluation_id}

Retrieves recent and historical evaluations

Route: POST /{user_id}/recalculate

Publishes events to trigger async rule execution

Routes: GET /rulebooks, GET /rulebooks/changes

Retrieves active rulebooks and audit trails

Fetches user data from User Service

Retrieves transaction history from Transactions Service

Gets active floats from Float Service

Retrieves ML insights from Insight Service

Fetches subscription status from Subscriptions Service

Gets payment information from Payments Service

Loads rulebooks from DynamoDB (with caching)

Filters rules by type (txns, insights, all)

Invokes individual Lambda rule functions

Collects rule results with features

Writes RuleOutcome to DynamoDB with 32-day TTL

Stores features map for debugging

Records calc_status (OK, NODATA, CALCERR)

Publishes event to Result Runner queue after all rules complete

Identifies the in-processing float and its collection payment that qualify for an early advance (most recent float ACHSENT, no other outstanding, latest collection a T-1 day-before-ACH run — TOMORROW_FIRST_FLOAT, or TOMORROW_RETURNING_FLOAT behind the returning-float GrowthBook flag), via float-service collection history, and runs float_evaluation.EvaluateEarlyAdvance over the run’s transactions. Only when the user clears does it feed RuleGoodStanding (and, via the result runner, the stored early_advance_float_id/early_advance_payment_id/early_advance_day).

When the user clears, it builds the early_advance_eligible notification payload (email, float, day, rollover end_date, payment) and carries it on the rule-run-completed event. It does NOT send the notification itself — the result runner does, once it confirms the user passed underwriting.

Fetches all RuleOutcomes for user from DynamoDB

Loads rulebooks with caching

Filters rulebooks by type (float vs loan)

Applies A/B test filtering (apply_to percentage)

Sorts by priority (descending)

Evaluates sequentially until approval or superseding rulebook

Creates EvaluationResult with 32-day TTL

Stores rulebook_results array with individual outcomes

Records deciding_rulebook for approved users

Sets evaluation_status based on data quality

Persists early_advance_float_id/early_advance_payment_id/early_advance_day (lifted from RuleGoodStanding’s outcome) for the live early-advance check

When the float evaluation is approved (float_results.approved) AND the rule runner carried an early-advance nudge on the event, sends the Iterable early_advance_eligible event (and payments.ach.early_advance_float metric). Gating on approval here — rather than in the rule runner, which does not know the final decision — ensures a user who cleared early advance but was denied by another rule is never notified.

Requires the SM_ITERABLE_NAME secret (Iterable API key); failures are logged and never fail the result run

Calculates float_rank and sub_rank

Determines eligible float tiers

Checks for limit increase eligibility

Updates FloatProfile if increase detected

Publishes evaluation complete events

Triggers Segment tracking for CFI changes

Receives float.created events from EventBridge via SQS

Extracts float_id, user_id, amount from event payload

Retrieves corresponding EvaluationResult from DynamoDB

Creates HistoricalEvaluation entity (permanent, no TTL)

Stores complete evaluation snapshot:

Preserves exact evaluation used for credit decision

Enables dispute resolution and auditing

Historical floats used to calculate float_rank

Enables "highest float ever taken" tracking

Supports reactivating user limit determination

After the historical eval is preserved, emits an underwriting_recalculate_user event (source underwriting.api) to the FloatMe event bus

This is the same event the API’s POST /{user_id}/recalculate endpoint emits, so it is matched by rule_runner_event_rule and triggers a fresh Rule Runner evaluation for the user

Fires for every created float — including when no prior eval existed to preserve — so the user’s evaluation always reflects the newly created float

Receives user.signup.completed events

Extracts user_id from event payload

Checks if profile already exists (idempotency)

Creates default FloatProfile:

Writes to DynamoDB with timestamp

Skips creation if profile already exists

Prevents duplicate profiles from event replays