Built with care. Tracked openly.

Route website inquiries to the owning church with spam controls, consent and staff resolution history.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Route website inquiries to the owning church with spam controls, consent and staff resolution history.

Database contract: contact_forms, submissions, assignment_events, notification_outbox

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Wrong-domain form cannot route private message to other church; duplicate POST creates one inquiry.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Set Up a Contact Us Form on Your Website

Edit safe page titles, summaries, canonical URLs and social images per published revision.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Edit safe page titles, summaries, canonical URLs and social images per published revision.

Database contract: page_versions(seo_title,description,canonical_url,social_image_id), domains

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Private/member content omitted from sitemap and snippets; cross-domain canonical validated.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Search Engine Optimization and Social Sharing

Upload validated media, label alt text, organize galleries and control public/private publishing.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Upload validated media, label alt text, organize galleries and control public/private publishing.

Database contract: media_assets(owner_org,mime,hash,visibility), galleries, gallery_items

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Executable uploads rejected; private files require scoped access; referenced media deletion guarded.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• How do I create an image gallery?

Build church menus with nested ordered items and responsive accessible display.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Build church menus with nested ordered items and responsive accessible display.

Database contract: menus, menu_items(parent_id,position,target_type,target_id)

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Cycles rejected; hidden/private pages not leaked; keyboard mobile navigation works.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• How to Create a Multilevel Menu

Manage event sessions with individual capacities and expiring checkout reservations.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Manage event sessions with individual capacities and expiring checkout reservations.

Database contract: event_sessions, capacity_holds(expires_at), tickets(session_id), checkins

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Concurrent requests cannot oversell; expired holds released; cancel restores correct session.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• How to Set Up Time Slot Reservations for Events

Allow authorized ticket holder or event staff to correct attendee details with audit and reissue policy.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Allow authorized ticket holder or event staff to correct attendee details with audit and reissue policy.

Database contract: attendees(version), attendee_change_events, ticket_versions

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Changing attendee does not change paying donor or tax receipt; stale edits rejected.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• How to Change Attendee Names for Events

Collect donor declarations with effective dates and eligible-gift links, retaining immutable wording and change history for issuer reports.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Collect donor declarations with effective dates and eligible-gift links, retaining immutable wording and change history for issuer reports.

Database contract: gift_aid_declarations(person_id,organization_id,wording_version,effective_from,effective_to,address_snapshot), eligible_gift_links

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Only eligible gifts and valid declarations exported; cancellation affects required period; legal requirements separately verified.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Gift Aid (UK Only)

Resolve explicit donor/issuer receipt language and persist chosen language/template version in each issued snapshot.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Resolve explicit donor/issuer receipt language and persist chosen language/template version in each issued snapshot.

Database contract: receipt_templates(locale,version), donor_receipt_preferences, receipt_documents(template_id,locale)

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: French preference selects French template; missing translation yields visible exception rather than mislabeled document.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Configuring Tax Receipts to Prioritize French Over English

Configure issuer line labels and safe merge values without altering recorded gift amounts or legal disclosure.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Configure issuer line labels and safe merge values without altering recorded gift amounts or legal disclosure.

Database contract: receipt_template_versions, receipt_line_labels, immutable document snapshots

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Unsupported merge token rejected; escaped text cannot inject markup; prior document unchanged.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• How to Customize Line Item Labels in the Tax Receipt Summary

Accept explicit promises with installment expectations, then match actual gifts; track pledged, received, outstanding and cancelled amounts separately.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Accept explicit promises with installment expectations, then match actual gifts; track pledged, received, outstanding and cancelled amounts separately.

Database contract: pledge_campaigns, pledges, pledge_installments, pledge_gift_links, pledge_events

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Promise not receipted as donation; partial fulfillment correct; duplicate gift link rejected.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Guide to Pledges (Promises to Give)

Allow per-form experimental prompt after recurring enrollment; record 0/2/3/4 percent choice and original amount; report/export results without changing billing.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: Givecloud Auto Scale is currently an experiment collecting annual-increase choices; it does not yet automatically increase recurring gifts.

Matthew25 workflow: Allow per-form experimental prompt after recurring enrollment; record 0/2/3/4 percent choice and original amount; report/export results without changing billing.

Database contract: REQUIRED experiment_definitions, form_experiments, experiment_consents(plan_id,percent,original_minor,notice_version), experiment_exports.

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Opt-in alone causes no plan amount change; duplicate submission one result; church-specific CSV respects permissions.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• 🧪 Experiments

After gift, collect separate public/private note and approved emoji; moderate public display and keep private note out of widgets and CRM fields unless explicitly mapped.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: After gift, collect separate public/private note and approved emoji; moderate public display and keep private note out of widgets and CRM fields unless explicitly mapped.

Database contract: gift_messages(gift_id,visibility,body,moderation_status), reaction_options, gift_reactions

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Private note never in honor roll; anonymous donor identity hidden; retries produce one reaction.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• GE: Customize Experience

Offer address suggestions through configured provider while allowing validated manual international addresses.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Offer address suggestions through configured provider while allowing validated manual international addresses.

Database contract: address_provider_connections, person_addresses, checkout_address_snapshots

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Provider unavailable does not block manual entry; suggestion does not verify identity.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Address Auto-Complete at Checkout

Accept allowlisted prefill parameters and validate again server-side; never trust URL prices, recipient merchant or identity assertions.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Accept allowlisted prefill parameters and validate again server-side; never trust URL prices, recipient merchant or identity assertions.

Database contract: form_field_definitions, checkout_field_values, checkout_sessions

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Unknown fields ignored; tampered fund/amount rejected; confidential values excluded from share links.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Use URLs to Pre-Fill Custom Fields on Your Donation Page

Copy design and safe configuration into an unpublished new form with fresh identity and version history.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Copy design and safe configuration into an unpublished new form with fresh identity and version history.

Database contract: giving_forms, form_versions, form_fields, duplication_events

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: New form does not share editable version or publish itself; credential references not copied across churches.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• How to Duplicate a Giving Experience

Publish start/end schedule per church timezone, enforce at checkout and prevent paying to archived funds.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Publish start/end schedule per church timezone, enforce at checkout and prevent paying to archived funds.

Database contract: form_versions(starts_at,ends_at,status), checkout_sessions, fund eligibility

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Just-expired form rejected before authorization; existing settled gifts remain available.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Setting an Active Date for your Classic Forms

Require acknowledgment of versioned privacy notice separately from optional fundraising marketing consent.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Require acknowledgment of versioned privacy notice separately from optional fundraising marketing consent.

Database contract: privacy_notices, checkout_consents(notice_id,person_id,accepted_at), consent_events

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Privacy acceptance never implies email opt-in; missing mandatory consent blocks completion.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Create a Privacy Policy Checkbox on Classic Forms

Map church donors/constituents, contribution funds and separate fee/shipping/tax gifts; reconcile returned IDs and surface sync limitations.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The documented beta supports constituent and gift sync, but recurring-plan edits, some split designation behavior and later-issued receipts have limitations.

Matthew25 workflow: Map church donors/constituents, contribution funds and separate fee/shipping/tax gifts; reconcile returned IDs and surface sync limitations.

Database contract: REQUIRED integration_connections(organization_id,provider), constituent_links, gift_links, mapping_versions, sync_outbox, attempts, conflicts.

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: One-way profile sync cannot overwrite from untrusted remote records; split grouping correct; manual reconciliation for unsupported receipt and recurring updates.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• BETA: Blackbaud Raiser's Edge NXT (Overview)

Connect each church’s Blackbaud account and per-currency hosted payment configuration; independently reconcile ambiguous ACH status and refund amounts.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The documented BBMS beta uses hosted checkout and currency configuration. ACH status, failed-attempt events and refund detail availability have limitations.

Matthew25 workflow: Connect each church’s Blackbaud account and per-currency hosted payment configuration; independently reconcile ambiguous ACH status and refund amounts.

Database contract: REQUIRED merchant_connections, hosted_payment_sessions, payment_events, reconciliation_exceptions, refund_evidence.

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Hosted failure not treated as success; pending ACH not receipted as settled; partial refund cannot be inferred from generic Refunded status.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• BETA: Blackbaud Integrated Payments (BBMS)

Use a church-owned direct-debit connection with mandate authorization, pending collection and asynchronous settlement.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Use a church-owned direct-debit connection with mandate authorization, pending collection and asynchronous settlement.

Database contract: merchant_accounts, mandates, payment_events, returns, organization-scoped external IDs

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Mandate revocation stops collection; delayed failures reverse provisional state; no raw bank credentials.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• GoCardless

Configure eligible church gateway accounts and route their supported currencies/payment methods.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Configure eligible church gateway accounts and route their supported currencies/payment methods.

Database contract: merchant_accounts, gateway_capabilities, token references and settlement links

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Unsupported currency rejected; gateway credential and merchant boundaries enforced.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Cayman Gateway

Calculate applicable commerce sales tax using shipping/billing jurisdiction and line classification; store quote and committed transaction separately.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Calculate applicable commerce sales tax using shipping/billing jurisdiction and line classification; store quote and committed transaction separately.

Database contract: tax_connections, tax_quotes, tax_lines, order_tax_snapshots, tax_adjustments

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Donation-only line is not blindly treated as merchandise; refund reverses allocated tax; outage does not silently assume zero.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• TaxCloud

Provide scoped event subscriptions and authenticated actions with durable delivery and revocation.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Provide scoped event subscriptions and authenticated actions with durable delivery and revocation.

Database contract: api_clients, scopes, webhook_subscriptions, event_outbox, delivery_attempts

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Revoked client denied; replay idempotent; church A cannot subscribe to church B.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Zapier Integration

Synchronize opted-in church contacts and mapped tags through retriable jobs.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Synchronize opted-in church contacts and mapped tags through retriable jobs.

Database contract: marketing_connections, external_contact_links, consent_events, sync_jobs

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Unsubscribe stops marketing sync; foreign church consent not reused; duplicate contact handled.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Active Campaign

Map church lists and explicit channel consent; reconcile subscription state without overwriting opt-out.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Map church lists and explicit channel consent; reconcile subscription state without overwriting opt-out.

Database contract: marketing_lists, list_mappings, contact_links, suppression_events

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Provider failure retried; opted-out contact not re-added by profile update.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Constant Contact

Map church audience, tags and permitted contact fields and propagate opt-out through signed webhook handling.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Map church audience, tags and permitted contact fields and propagate opt-out through signed webhook handling.

Database contract: audience_mappings, subscriber_links, webhook_inbox, suppression_events

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Webhook replay safe; unsubscribed person never auto-resubscribed.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Mailchimp

Map congregation and giving exports to church-owned Servant Keeper identifiers with preview and reconciliation.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Map congregation and giving exports to church-owned Servant Keeper identifiers with preview and reconciliation.

Database contract: integration_connections, field_mappings, export_jobs, external_links

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: No multi-church profile leakage; unrecognized mapping returns visible exception.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• ServantKeeper

Version recurring-to-pledge mappings and reconcile cancel/recreate behavior when changing paid pledge schedules.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Version recurring-to-pledge mappings and reconcile cancel/recreate behavior when changing paid pledge schedules.

Database contract: recurring_external_links, pledge_mapping_versions, sync_jobs, replacement_links

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Old pledge remains traceable; cancelled/recreated mapping does not double count; retries no duplicate pledge.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Enhanced DP Pledges for Automated Pledge Updates

Inventory merchant-scoped tokens and recurring mandates, obtain processor transfer procedure, reconcile test samples, then cut over with rollback boundary.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Inventory merchant-scoped tokens and recurring mandates, obtain processor transfer procedure, reconcile test samples, then cut over with rollback boundary.

Database contract: migration_batches, token_mapping_rows, mandate_migration_events, cutover_state

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: No raw card export; foreign vault references rejected; original mandate preserved until verified replacement.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Switching Gateways: What to Keep in Mind

Track platform subscription plans, invoices, payment methods and cancellation separately from church donations and donor fees.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Track platform subscription plans, invoices, payment methods and cancellation separately from church donations and donor fees.

Database contract: platform_plans, organization_subscriptions, platform_invoices, invoice_lines, billing_events

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Platform invoice never becomes charitable receipt; cancellation effective date preserved; no merchant pooling.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Guide to Givecloud Billing

Store each staff member’s church-scoped dashboard shortcuts in MySQL and render only currently authorized destinations.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Store each staff member’s church-scoped dashboard shortcuts in MySQL and render only currently authorized destinations.

Database contract: staff_dashboard_preferences(account_id,organization_id), ordered_shortcuts

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Preference persists without localStorage; revoking access removes shortcut target.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Adding and Removing Pins on Your Dashboard

Allow scoped moderation to archive and reactivate a fundraiser while preserving gifts, links and review history.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Allow scoped moderation to archive and reactivate a fundraiser while preserving gifts, links and review history.

Database contract: peer_fundraisers(status,version), moderation_events, donation_attributions

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Archived page stops accepting gifts; reactivation requires eligible receiving campaign.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• How to Reactivate a Peer-to-Peer Fundraising Page

Attribute verified offline gifts to approved fundraisers with donor public-display consent.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Attribute verified offline gifts to approved fundraisers with donor public-display consent.

Database contract: donation_attributions, recognition_preferences, honor_roll_entries

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Void removes amount from progress; anonymous or private identity cannot leak.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• How to Show an Offline Donor's Name on an Honor Roll

Allow daily billing with explicit church timezone, cycle limit or end date. Preserve local schedule across DST without duplicate occurrence.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Allow daily billing with explicit church timezone, cycle limit or end date. Preserve local schedule across DST without duplicate occurrence.

Database contract: REQUIRED recurring_plans(cadence,anchor_date,timezone,max_cycles,end_date), recurring_occurrences(plan_id,sequence,due_at,status); unique plan/sequence.

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Daily runs across DST, cutoff date and fixed cycle limit; paused plans produce no charge.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Adding Daily Donation Frequency

Upload and map new commitments; validate donor, item, currency and same-merchant token; support explicit manual commitments without a token; preview then process durable per-row results.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: Givecloud can bulk-create automatic plans using existing valid Givecloud payment methods, or manual plans without them; outside-gateway vault IDs are not interchangeable.

Matthew25 workflow: Upload and map new commitments; validate donor, item, currency and same-merchant token; support explicit manual commitments without a token; preview then process durable per-row results.

Database contract: REQUIRED import_jobs, import_rows(raw_values,normalized_values,error,status), recurring_plans, merchant_scoped_payment_tokens, external_links.

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Foreign donor token rejected; no token cannot create automatic collection; replay import creates no duplicate; mixed valid/invalid rows reconcile.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Bulk Create Recurring Payment Plans (RPPs)

Preview before/after amounts, dates, cadence, cost contributions and cancellations; blank means unchanged; zero explicitly removes fee contribution. Apply authorized changes with old-version checks and row-level results.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: Givecloud bulk updates accept recurring profile IDs, treat blank fields as unchanged, and distinguish zero DCC. Reactivation and CRM propagation have documented restrictions.

Matthew25 workflow: Preview before/after amounts, dates, cadence, cost contributions and cancellations; blank means unchanged; zero explicitly removes fee contribution. Apply authorized changes with old-version checks and row-level results.

Database contract: REQUIRED recurring_change_jobs/rows(plan_id,expected_version,before_json,after_json,result), recurring_plan_events, crm_sync_jobs.

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Unknown ID is a visible row error; stale row rejected; blank preserves value; zero removes costs; cancelled plan not silently reactivated.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Update Recurring Payment Plans (RPP) via Import

Track expected cash/check gifts as commitments and match each occurrence to an actually received gift; never book expected amounts as paid.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Track expected cash/check gifts as commitments and match each occurrence to an actually received gift; never book expected amounts as paid.

Database contract: REQUIRED recurring_plans(collection_mode), recurring_occurrences, occurrence_gift_links(unique donation_id), missed_occurrence_reasons.

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Expected unpaid occurrence excluded from receipts; one gift cannot fulfill twice; cancelling future schedule preserves prior gifts.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Managing Recurring Cash, Check, and Offline Payments

Replace coarse role assumptions with named capabilities for each write/read/refund/export/import/publishing operation and report.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Replace coarse role assumptions with named capabilities for each write/read/refund/export/import/publishing operation and report.

Database contract: roles, capability_definitions, role_capabilities, organization_user_roles, permission_change_events

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Finance view does not imply refund permission; care access remains separate; revoked permissions apply immediately.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Givecloud Account: User Permissions

Enroll staff authentication factor, require challenge for privileged login, store hashed recovery codes and auditable resets.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Enroll staff authentication factor, require challenge for privileged login, store hashed recovery codes and auditable resets.

Database contract: account_factors(encrypted_secret), recovery_codes(hash,used_at), authentication_challenges, sessions

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Replay challenge rejected; recovery code one use; factor removal requires reauthentication.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Setup Two Factor Authentication on your Givecloud Account

Provide time-limited staff assistance with visible impersonation banner, constrained capabilities and full actor/subject audit.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Provide time-limited staff assistance with visible impersonation banner, constrained capabilities and full actor/subject audit.

Database contract: support_sessions(staff_account_id,subject_person_id,organization_id,reason,expires_at), assistance_events

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Cannot access donor other-church history; cannot authorize charge or alter PIN as donor; expiry enforced.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• How To Login As the Supporter/Donor In Givecloud

Screen eligible payment identities via approved provider; retain match evidence and human disposition without claiming a name match is conclusive.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Screen eligible payment identities via approved provider; retain match evidence and human disposition without claiming a name match is conclusive.

Database contract: screening_jobs, match_candidates, review_decisions, payment_holds

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Potential match held for review; timeout not silently cleared; reviewer decisions audited.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• How Givecloud Leverages OFAC Sanctions List

Verify selected high-risk checkout contact with expiring, rate-limited challenges before payment authorization.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Verify selected high-risk checkout contact with expiring, rate-limited challenges before payment authorization.

Database contract: verification_challenges(hash,attempts,expires_at,purpose), delivery_jobs, risk_decisions

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Code reuse and brute force blocked; challenge tied to same checkout/contact; provider outage visible.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• One-Time Code Verification for Donations

Offer eligible pickup or shipping per item and preserve fulfillment method on order lines.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Offer eligible pickup or shipping per item and preserve fulfillment method on order lines.

Database contract: fulfillment_methods, pickup_locations, order_fulfillment_groups, status_events

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Pickup has no shipping charge; mixed delivery groups priced correctly; cancellation releases reserved stock.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Shipping: In-Store Purchases and Pick-up

Grant authenticated, expiring access to purchased downloadable or streamable content after verified payment.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Grant authenticated, expiring access to purchased downloadable or streamable content after verified payment.

Database contract: digital_assets, purchase_entitlements, access_tokens(hash,expires_at), access_logs

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Guessed asset IDs denied; refunded entitlement revoked; private file never directly public.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• How to Sell Downloadable or Streamable Content

Enforce configured item minimum/maximum per order and membership eligibility before reserving stock.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Enforce configured item minimum/maximum per order and membership eligibility before reserving stock.

Database contract: product_purchase_limits, cart_lines, inventory_reservations

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Client quantity tampering rejected; bundles consume component stock once.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• How to Edit the Quantity Selection Limit

Configure maturity rules and track eligible, mature and ended beneficiary records while preserving sponsorship history.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Configure maturity rules and track eligible, mature and ended beneficiary records while preserving sponsorship history.

Database contract: beneficiaries(birth_date,maturity_policy_id,status), maturity_policies, sponsorship_events

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Date boundary and unknown birth date handled; maturity does not silently continue disallowed collection.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Sponsorships: Add or Edit the Age of Maturity for your Sponsees

Stage beneficiary and sponsor records, validate identifiers and relationships, review duplicate candidates, then import with row-level outcomes.

Acceptance: See individual specification below.

Dependency: Implementation and source restriction reconciliation still required.

Source behavior / boundary: The linked Givecloud help article documents this capability. Detailed compatibility and configuration restrictions must be reconciled before parity acceptance.

Matthew25 workflow: Stage beneficiary and sponsor records, validate identifiers and relationships, review duplicate candidates, then import with row-level outcomes.

Database contract: sponsorship_import_jobs/rows, beneficiary_external_links, sponsorships

Who can do what: Church-scoped staff capability; donors can change only their own authorizations. Every query and external mapping includes the receiving organization.

Validation and recovery: Validate before commit; preserve prior version and audit; retry external operations with stable idempotency keys; surface unresolved rows without reporting success.

Required acceptance tests: Duplicate import idempotent; private fields never published by default.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Sponsorship Import Template

Matthew25 release requirement: Event-triggered email. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify event-triggered email through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Template personalization. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify template personalization through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Branded message templates. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify branded message templates through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Staff notifications. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify staff notifications through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Supporter notifications. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify supporter notifications through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Daily/weekly/monthly insights. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify daily/weekly/monthly insights through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: SMS keyword giving. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify sms keyword giving through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Text pledges. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify text pledges through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Custom text responses. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify custom text responses through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Suppression and unsubscribe. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify suppression and unsubscribe through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Website page editor. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify website page editor through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Website menus. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify website menus through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Blog publishing. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify blog publishing through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Scheduled content publishing. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify scheduled content publishing through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Custom domain verification. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify custom domain verification through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Secure domain certificates. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify secure domain certificates through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Content revision rollback. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify content revision rollback through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Managed redirects. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify managed redirects through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: WordPress embedding. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify wordpress embedding through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: DonorPerfect synchronization. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify donorperfect synchronization through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: DonorPerfect field mappings. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify donorperfect field mappings through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Historical CRM giving. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify historical crm giving through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: CRM duplicate matching. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify crm duplicate matching through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Split gift / individual gift mapping. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify split gift / individual gift mapping through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Salesforce synchronization. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify salesforce synchronization through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: SafeSave connector. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify safesave connector through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Stripe connector. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify stripe connector through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Authorize.net connector. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify authorize.net connector through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Braintree connector. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify braintree connector through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Vanco connector. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify vanco connector through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Paysafe connector. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify paysafe connector through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: NMI connector. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify nmi connector through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Multiple gateway accounts. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify multiple gateway accounts through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: API credentials and scopes. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify api credentials and scopes through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Outbound webhooks. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify outbound webhooks through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Self-service imports. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify self-service imports through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Import preview and recovery. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify import preview and recovery through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Scoped exports. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify scoped exports through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Analytics tags. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify analytics tags through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Conversion funnels. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify conversion funnels through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Recommendation experiments. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify recommendation experiments through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Trained recommendation models. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify trained recommendation models through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Satisfaction surveys. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify satisfaction surveys through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Supporter segmentation. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify supporter segmentation through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Immutable audit history. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify immutable audit history through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Background job recovery. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify background job recovery through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Server-side release history. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify server-side release history through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Rollback verification. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify rollback verification through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Combined personal giving history. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify combined personal giving history through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Church-specific donation letters. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify church-specific donation letters through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Recurring commitments dashboard. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify recurring commitments dashboard through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Payment token management. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify payment token management through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Donor contact self-service. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify donor contact self-service through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Purchased ticket access. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify purchased ticket access through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Email-link sign-in. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify email-link sign-in through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: External social sign-in. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify external social sign-in through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: OpenID Connect sign-in. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify openid connect sign-in through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Cross-domain identity handoff. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify cross-domain identity handoff through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Event registrations. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify event registrations through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Ticket inventory and capacity. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify ticket inventory and capacity through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Attendee custom fields. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify attendee custom fields through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Event sponsorship packages. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify event sponsorship packages through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: QR ticket admission. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify qr ticket admission through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Repeat-entry policies. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify repeat-entry policies through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Attendance reporting. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify attendance reporting through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Virtual event video. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify virtual event video through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Moderated event conversation. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify moderated event conversation through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Live event pledges. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify live event pledges through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Event sales-tax calculation. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify event sales-tax calculation through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Ticket/product bundles. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify ticket/product bundles through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Event discount codes. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify event discount codes through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Campaign discovery. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify campaign discovery through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: General church giving funds. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify general church giving funds through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Designated project funds. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify designated project funds through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Campaign pages and stories. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify campaign pages and stories through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Outcome-based donation choices. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify outcome-based donation choices through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Form visual editor. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify form visual editor through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Church brand settings. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify church brand settings through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Partner-branded campaigns. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify partner-branded campaigns through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Hosted donation pages. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify hosted donation pages through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Inline donation forms. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify inline donation forms through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Popup donation forms. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify popup donation forms through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Embeddable donor recognition. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify embeddable donor recognition through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Embeddable progress tracking. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify embeddable progress tracking through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Guided checkout. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify guided checkout through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: QR giving entry. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify qr giving entry through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Currency-aware checkout. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify currency-aware checkout through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Translated giving forms. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify translated giving forms through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Personalized suggested amounts. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify personalized suggested amounts through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Tribute donations. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify tribute donations through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Ecard delivery. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify ecard delivery through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Anonymous public recognition. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify anonymous public recognition through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Donor messages. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify donor messages through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Business contributions. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify business contributions through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Multiple-fund allocations. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify multiple-fund allocations through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Custom donation fields. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify custom donation fields through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Campaign sharing links. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify campaign sharing links through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Short campaign links. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify short campaign links through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Abandonment reminders. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify abandonment reminders through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Countdown and fundraising goals. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify countdown and fundraising goals through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Video thank-you messages. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify video thank-you messages through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Custom next-action links. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify custom next-action links through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Referral attribution. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify referral attribution through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Shared network identity. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify shared network identity through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Phone and PIN access. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify phone and pin access through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Verification and account recovery. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify verification and account recovery through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Multiple phone numbers. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify multiple phone numbers through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Multiple email addresses. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify multiple email addresses through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Multiple mailing addresses. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify multiple mailing addresses through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Receipt identity and salutations. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify receipt identity and salutations through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Household relationships. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify household relationships through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Dependency: Implemented portions and remaining limits are recorded in the detailed specification. Full release acceptance is not met.

Source behavior / boundary: Matthew25 congregation extension; do not equate church households with Givecloud purchased memberships.

Matthew25 workflow: Congregation staff create a household, select a church campus, link consented congregants with relationship labels, end relationships, and archive or restore the household. No relationship shares financial or care access.

Database contract: INSTALLED: church_households(id,organization_id,name,campus_id,status,version); household_members(id,organization_id,household_id,person_id,relationship,status,joined_at,ended_at). Composite foreign keys constrain campus, household and congregation to the same church.

Who can do what: Organization congregation staff; household membership does not authorize access. Global profile edits remain donor/platform controlled.

Validation and recovery: Lock household while updating; reject stale versions, foreign campuses, archived household additions and nonconsented members. Retain ended links.

Required acceptance tests: Update relationship twice produces one row; foreign-church campus rejected; end relationship retains record; archive/restore round-trip.

Actual implementation evidence: 0.3.0 server workflow; transaction tests cover duplicate links, history and tenant constraints. Global household-sharing invitations remain a distinct unfinished extension. Follow-up: authenticated live route passed; mobile campus/household creation and full-cost estimate checked at 390px without overflow.

Matthew25 release requirement: Business donor contacts. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify business donor contacts through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Duplicate profile review and merge. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify duplicate profile review and merge through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Church-specific profile consent. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify church-specific profile consent through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Multiple congregation memberships. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify multiple congregation memberships through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Membership classification. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify membership classification through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Church-local member numbers. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify church-local member numbers through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Church role permissions. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify church role permissions through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Campuses and ministry groups. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify campuses and ministry groups through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Dependency: Server transactions, HTTP workflows and access checks verified. Full product release acceptance remains incomplete.

Source behavior / boundary: Matthew25 congregation extension.

Matthew25 workflow: Manage multiple campus addresses and phones; assign households and volunteer shifts to an active campus. Ministry groups retain their existing roster and attendance workflows.

Database contract: INSTALLED church_campuses(id,organization_id,name,address_line1,address_line2,city,region,postal_code,country,phone,status,version). Unique organization/name and composite id/organization key.

Who can do what: Congregation managers and organization administrators only.

Validation and recovery: Validate country and E.164 phone; optimistic version; archived campuses cannot be newly assigned; referenced history remains.

Required acceptance tests: Persist all address fields; reject stale save and cross-church campus; archived campus excluded from new selection.

Actual implementation evidence: 0.3.0 implemented, server tests passed for persistence/stale/cross-church constraints; existing groups in 0.2.0. Follow-up: authenticated live route passed; mobile campus/household creation and full-cost estimate checked at 390px without overflow.

Matthew25 release requirement: Group attendance. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify group attendance through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Volunteer assignments. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify volunteer assignments through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Dependency: Server transactions, HTTP workflows and access checks verified. Full product release acceptance remains incomplete.

Source behavior / boundary: Matthew25 congregation extension.

Matthew25 workflow: Coordinator creates bounded-capacity shifts, invites connected congregants, and records acceptance, cancellation and completed service minutes. Donors respond for themselves. Shift cancellation releases pending places without removing history.

Database contract: INSTALLED volunteer_shifts(organization_id,campus_id,starts_at,ends_at,capacity,status,version); volunteer_assignments(organization_id,shift_id,person_id,status,hours_minutes). Unique shift/person.

Who can do what: Coordinator writes assignments and completion; donor only own accept/decline/cancel.

Validation and recovery: Lock shift before capacity calculation; invitations, accepted and completed places consume capacity. Reject overbooking, wrong person, inactive member and stale shift edit.

Required acceptance tests: Capacity-one invitation blocks second reservation; donor cannot alter others or certify hours; authorized completion records minutes; cancelled shifts reject signup.

Actual implementation evidence: 0.3.0 server actions and screens implemented; assignment capacity and permission tests passed. Concurrent HTTP test still required. Follow-up: concurrent HTTP overbooking test exposed a repeatable-read snapshot bug; changed reserved-place reads to locking current reads and the race passed. Authenticated HTTP rendering also passed.

Matthew25 release requirement: Private member care notes. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify private member care notes through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Dependency: Server transactions, HTTP workflows and access checks verified. Full product release acceptance remains incomplete.

Source behavior / boundary: Matthew25 congregation extension.

Matthew25 workflow: Explicitly authorized care staff open church-owned cases, assign follow-up dates, append private notes, resolve or close, and reopen when needed. Notes are immutable history.

Database contract: INSTALLED care_access(organization_id,account_id,status,granted_by); care_cases(organization_id,person_id,assigned_account_id,due_on,status,version); care_notes(case_id,organization_id,body,created_by,created_at).

Who can do what: Organization administrator grants/revokes access; even platform administrators need an eligible church role and explicit grant to read notes. No finance, directory or household inheritance.

Validation and recovery: Check grant on every operation and page; lock case and check version; closed cases reject notes. Do not include note text in general audit.

Required acceptance tests: No-grant admin denied; revoked grant denied; two notes remain separate; closed case blocked; general audit contains no care note text.

Actual implementation evidence: 0.3.0 tested actions; server-side pages enforce same grant check.

Matthew25 release requirement: Communication preferences. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify communication preferences through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Dependency: Consent controls implemented; delivery services are not connected.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Directory visibility. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify directory visibility through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Dependency: Server transactions, HTTP workflows and access checks verified. Full product release acceptance remains incomplete.

Source behavior / boundary: Matthew25 donor-controlled congregation directory extension.

Matthew25 workflow: Each connected donor chooses whether to list their name, preferred phone and preferred email separately for each church. Only connected congregants and congregation staff see the list.

Database contract: INSTALLED directory_choices(person_id,organization_id,show_name,show_phone,show_email,consent_id,version); immutable consent_events with directory notice version. Directory joins active membership and active person.

Who can do what: Only the donor can change their directory choices; staff cannot opt a donor in. Addresses, gifts and care notes never enter the directory response.

Validation and recovery: Turning off name also turns off phone/email; leaving suppresses entry dynamically; church A choices never propagate to church B.

Required acceptance tests: Independent channel flags; opt-out removes contacts; departed donor cannot opt in; second church unchanged; unconnected account denied.

Actual implementation evidence: 0.3.0 server tests cover consent flags and church isolation; live UI validation pending.

Matthew25 release requirement: Account invitations. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify account invitations through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Dependency: Private invitation enrollment and replay rejection tested; public SMS enrollment still requires a messaging provider.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Card payments. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify card payments through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Bank debit / ACH. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify bank debit / ach through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: PayPal checkout. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify paypal checkout through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Apple Pay. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify apple pay through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Google Pay. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify google pay through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Donor-advised fund grants. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify donor-advised fund grants through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Organization merchant routing. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify organization merchant routing through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Dependency: Implemented portions and remaining limits are recorded in the detailed specification. Full release acceptance is not met.

Source behavior / boundary: Givecloud documents multiple gateway options. User requires each Matthew25 church to have its own merchant account.

Matthew25 workflow: Church administrator registers processor account identity and environment. Verified connection must route every intent, recurring mandate, refund and settlement to the receiving church. Cross-church checkout requires separate authorized transactions.

Database contract: INSTALLED merchant_accounts(id,organization_id,provider,external_account_ref,environment,currency,status,verification_evidence,version). Unique provider/reference/environment prevents assignment to a second church. REQUIRED: payment_intents, payment_methods, mandates, refunds, settlements with composite merchant/organization keys.

Who can do what: Church administrator configures their routing; finance views their own records; platform onboarding must validate recipient ownership.

Validation and recovery: Registration creates unconfigured status only. No collection without verified provider credentials. Never assume a vault token works at another merchant.

Required acceptance tests: Two churches cannot share the same account record; token from merchant A cannot pay merchant B; webhook mismatch quarantined; recurring cancellation routed to original merchant.

Actual implementation evidence: 0.3.0 registry and unconfigured guard tested. Provider integration, tokenization, callbacks and real routing remain unimplemented.

• Supported Payment Gateways

Matthew25 release requirement: Zero / partial / full fee coverage. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify zero / partial / full fee coverage through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Dependency: Implemented portions and remaining limits are recorded in the detailed specification. Full release acceptance is not met.

Source behavior / boundary: Givecloud supports configured percentage/fixed cost coverage and form-level DCC visibility. Defaults differ among checkout types.

Matthew25 workflow: Finance versions cost policy; donor must choose none, half, full or custom in the future checkout. Current finance estimator persists each exact quote without creating a donation.

Database contract: INSTALLED fee_policies(rate_basis_points,fixed_minor,formula,explanation,created_by); fee_quotes(organization_id,person_id,policy_id,base_minor,suggested_minor,contribution_minor,selection,currency,policy_snapshot,expires_at). REQUIRED payment consent must link quote and amount.

Who can do what: Finance configures and previews; production checkout must obtain donor authorization for total including costs.

Validation and recovery: Integer arithmetic: gross-up ceil((base*bps+fixed*10000)/(10000-bps)); simple ceil((base*bps+fixed*10000)/10000). Reject invalid rate, negative/oversized contribution, expired checkout quote.

Required acceptance tests: 100 USD at 2.9%+0.30: gross-up 3.30, half 1.65, simple 3.20; custom 1.23 exact; none zero; policy edit preserves snapshot.

Actual implementation evidence: 0.3.0 finance estimator tested; donor checkout and payment integration unfinished. Follow-up: authenticated live route passed; mobile campus/household creation and full-cost estimate checked at 390px without overflow.

• How to set up Donor Covers Cost (DCC)
• GE: Payment & DCC

Matthew25 release requirement: Custom cost contribution. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify custom cost contribution through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Dependency: Implemented portions and remaining limits are recorded in the detailed specification. Full release acceptance is not met.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Adaptive cost suggestions. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify adaptive cost suggestions through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Source behavior / boundary: Givecloud Smart DCC presents tiered operational-cost choices using a proprietary, changing algorithm; it is not an exact processor-fee calculation.

Matthew25 workflow: Matthew25 must offer clearly labeled optional fundraising support with explicit zero option. Log model/rule version, presented tiers and donor selection; deploy a trained model only after validation against consented data.

Database contract: REQUIRED recommendation_models(version,training_window,metrics,status), cost_offers(organization_id,model_id,base_minor,tiers_json,selected_minor), experiments and outcomes; never mix actual expense with support contribution.

Who can do what: Finance enables policy; donors decide; model training excludes church-private profile and care data.

Validation and recovery: Fallback to reviewed deterministic rules when model unavailable; label estimates; no claim to reproduce Givecloud proprietary model or uplift.

Required acceptance tests: Offer/acceptance/rejection recorded once; no-cost path available; model rollback preserves historical offers; excluded private fields absent.

Actual implementation evidence: Unimplemented. Custom arithmetic estimator does not implement Smart DCC.

• The Power of Smart DCC

Matthew25 release requirement: Fee explanation and consent. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify fee explanation and consent through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Dependency: Implemented portions and remaining limits are recorded in the detailed specification. Full release acceptance is not met.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Processor expense reconciliation. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify processor expense reconciliation through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Fraud detection. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify fraud detection through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Configurable risk restrictions. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify configurable risk restrictions through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Refund allocation. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify refund allocation through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Payment disputes. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify payment disputes through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Settlement batches. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify settlement batches through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Signed payment callbacks. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify signed payment callbacks through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Idempotent payment handling. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify idempotent payment handling through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Personal campaign creation. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify personal campaign creation through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Team fundraising. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify team fundraising through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Fundraiser goals and avatars. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify fundraiser goals and avatars through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Fundraiser lists and filters. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify fundraiser lists and filters through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Content moderation. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify content moderation through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Fundraiser verification. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify fundraiser verification through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Milestone notices. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify milestone notices through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Rich campaign media. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify rich campaign media through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Social campaign sharing. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify social campaign sharing through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Received offline gifts. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify received offline gifts through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Manual giving entry. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify manual giving entry through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Individual acknowledgments. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify individual acknowledgments through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Annual donor statements. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify annual donor statements through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Organization issuer details. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify organization issuer details through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Historic donor address snapshots. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify historic donor address snapshots through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Goods/services value disclosures. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify goods/services value disclosures through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Intangible religious benefit handling. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify intangible religious benefit handling through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Noncash acknowledgment handling. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify noncash acknowledgment handling through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Jurisdiction-specific receipt rules. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify jurisdiction-specific receipt rules through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Receipt correction and replacement. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify receipt correction and replacement through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Dependency: Individual and annual printable letters implemented. Broader replacement/delivery workflows remain.

Source behavior / boundary: Givecloud supports receipt revision, voiding, reissue, and prior-version history. Earlier versions are marked void.

Matthew25 workflow: Authorized finance staff preview corrected issuer/donor snapshot, give reason, void prior document and issue linked replacement. Amount correction must originate in gift accounting, not freeform receipt edits.

Database contract: EXISTING receipt_documents and receipt_gift_links. REQUIRED replacement_of_id, revision_reason, rendered_document_hash, document_versions and delivery records; remove one-document-per-donation assumption with safe migration.

Who can do what: Issuer finance and donor read own; only issuer finance revises; replacement inherits same donor and church.

Validation and recovery: Lock source gifts and prior receipt; atomic void/reissue; preserve originals and download VOID status; invalid refund state blocks issue.

Required acceptance tests: Address correction does not change gift total; old version remains downloadable as void; double submission does not create duplicate current receipt.

Actual implementation evidence: Existing gift void and annual invalidation only. Full replacement workflow unimplemented.

• How to Revise, Void or Reissue a Tax Receipt

Matthew25 release requirement: Private receipt downloads. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify private receipt downloads through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Mail-ready donor letters. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify mail-ready donor letters through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Email receipt delivery. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify email receipt delivery through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Print and postal dispatch tracking. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify print and postal dispatch tracking through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Accounting codes. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify accounting codes through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Separate fee contribution coding. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify separate fee contribution coding through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Contribution reports. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify contribution reports through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Payment reports. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify payment reports through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Line-item reports. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify line-item reports through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Failed-payment reports. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify failed-payment reports through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Refund reports. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify refund reports through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Balanced financial journal. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify balanced financial journal through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Settlement reconciliation. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify settlement reconciliation through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Recurring gift enrollment. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify recurring gift enrollment through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Weekly and alternate-week schedules. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify weekly and alternate-week schedules through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Monthly and annual schedules. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify monthly and annual schedules through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Quarterly and semiannual schedules. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify quarterly and semiannual schedules through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Fixed installment limits. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify fixed installment limits through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Recurring gift editing. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify recurring gift editing through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Pause and resume. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify pause and resume through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Cancellation. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify cancellation through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Payment expiry notifications. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify payment expiry notifications through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Failed-payment retries. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify failed-payment retries through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Payment account updater. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify payment account updater through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Recurring authorization history. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify recurring authorization history through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Post-gift recurring invitation. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify post-gift recurring invitation through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Source behavior / boundary: Givecloud offers a monthly invitation after a one-time gift; administrators can customize text and suppress above a threshold, while suggested upsell amounts are not manually editable.

Matthew25 workflow: After confirmed original gift, show eligible recurring offer. Acceptance creates a separate explicit authorization with first collection date and receiving merchant; declining leaves original gift untouched.

Database contract: REQUIRED upsell_rules(organization_id,form_id,message,threshold_minor), upsell_offers(original_gift_id,rule_version,shown_amounts,status), recurring_authorizations(person_id,merchant_account_id,terms_snapshot,consented_at).

Who can do what: Church finance sets rule; donor accepts only for their own payment method; callbacks authorize only original receiving merchant.

Validation and recovery: No second charge from page refresh; suppress for excluded methods such as DAF; original gift remains intact if recurring authorization fails.

Required acceptance tests: Double submit makes one authorization; decline creates none; threshold suppresses; original receipt unchanged.

Actual implementation evidence: Unimplemented; dependencies include selected processor, tokenization and recurring scheduler.

• GE: Customize Experience

Matthew25 release requirement: Large-gift upsell suppression. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify large-gift upsell suppression through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Church-controlled upsell amounts. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify church-controlled upsell amounts through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Employer match discovery. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify employer match discovery through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Employer match tracking. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify employer match tracking through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Email opt-in after giving. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify email opt-in after giving through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Beneficiary profiles. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify beneficiary profiles through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Beneficiary discovery filters. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify beneficiary discovery filters through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Beneficiary field privacy. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify beneficiary field privacy through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Sponsorship commitments. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify sponsorship commitments through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Sponsorship capacity. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify sponsorship capacity through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Beneficiary updates. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify beneficiary updates through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Sponsor activity timeline. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify sponsor activity timeline through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Sponsor self-management. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify sponsor self-management through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Physical merchandise. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify physical merchandise through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Digital merchandise. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify digital merchandise through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Product variants. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify product variants through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Product categories. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify product categories through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Stock movements. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify stock movements through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Checkout stock reservations. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify checkout stock reservations through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Inventory replenishment. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify inventory replenishment through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Discount rules. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify discount rules through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Shipping calculations. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify shipping calculations through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Carrier fulfillment integration. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify carrier fulfillment integration through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Unified donation and purchase cart. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify unified donation and purchase cart through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Donation add-on at checkout. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify donation add-on at checkout through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Membership levels and codes. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify membership levels and codes through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Paid membership renewal. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify paid membership renewal through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Source behavior / boundary: Givecloud supports dated, rolling and lifetime memberships. Its documented recurring-payment workaround does not automatically extend membership expiry or remove membership after plan cancellation.

Matthew25 workflow: Matthew25 will explicitly model paid membership entitlements separately from congregation membership, including configured renewal duration, renewal price and cancellation effects. Automatic extension is a Matthew25 improvement, not a verified Givecloud capability.

Database contract: REQUIRED membership_types, membership_prices, paid_memberships(starts_on,expires_on,status), entitlement_events(payment_id,extension_days,source_event_id unique), recurring plan linkage.

Who can do what: Church membership staff; donor sees own benefits; payment confirmation controls paid entitlement activation.

Validation and recovery: Duplicate payment event cannot double-extend; failed payment cannot grant benefit; cancellation follows recorded policy and preserves prior paid period.

Required acceptance tests: Fixed/rolling/lifetime cases, one-time renewal and repeated webhook; congregation connection survives paid membership expiry.

Actual implementation evidence: Not implemented. Proposed data structures are design requirements, not installed tables.

• Membership Renewals with Givecloud

Matthew25 release requirement: Member benefit discounts. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify member benefit discounts through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.

Matthew25 release requirement: Protected member content. Implement a complete authorized workflow with persistent relational records, scoped visibility, validation and recoverable changes; this entry is not a completion claim.

Acceptance: Verify protected member content through the real user workflow, canonical database re-read, access-control checks and failure/retry behavior.

Specification gap: Individual data, workflow, permission and recovery contracts are not yet complete for this requirement.