Contact person: STRIPE INTERGATED UI TRASNACTION PLATFORM

Phone:Show

Email:Show

Location: Québec, Canada

Budget: Recommended by industry experts

Time to start: As soon as possible

Project description:
"Project summary

A hosted payment gateway you run on cPanel (Node.js 18 + MySQL) that processes all payments through Stripe and uses Twilio Pay for voice/DTMF card entry. The UI is server-rendered HTML (dark mode, premium) with smooth “processing” animations. For the initial test phase there’s no login/roles. The system produces a daily settlement report at 23:59 America/Toronto.

Payment rails (all CAD)

Card-Not-Present (CNP) Web

Stripe Elements, manual capture (capture_method=manual)

Single capture only (no multiple partial captures)

No ZIP / No 3DS

If not captured, auto-void at 4 days + 18 hours

Card-Present (Terminal)

WisePOS E via Stripe Terminal Cloud

Supports regular card rails + Interac (via the terminal)

Created as manual capture; single capture later

Interac refunds must be driven on the reader (server-initiated “refund on reader”)

Direct Debit (Canada, ACSS/PAD)

Stripe’s PAD flow (mandate collection page, IP/timestamp, legal text)

Debits are asynchronous; handle webhooks & returns

Mandate includes a finality clause (no dispute/recall with FI except as required by law)

Phone Payments (Twilio Pay + Stripe)

Employee-initiated calls into a Twilio flow using <Pay> with Stripe connector

On authorization: system sends an SMS to the caller with amount authorized + payment locator

Store Twilio Call SID + outcomes for audit

Global business rules

Currency: CAD only

Single capture per authorization (CNP and Terminal)

Auto-void any authorization still open at 4d18h

Refunds:

Only on captured transactions

Max refund = captured amount − prior refunds

Interac: refund on the terminal only (server-driven)

All others: refund via Stripe API from your UI

Receipts: HTML + printable/PDF (include preauth/capture blocks; signature only for card-present)

Daily Settlement Report at 23:59 America/Toronto (CSV + HTML/PDF)

High-level system architecture

Node.js 18 (Express or Fastify) behind cPanel Passenger

MySQL for persistence, migrations (Prisma/Knex)

Webhook handlers for Stripe & Twilio (signed, idempotent)

Jobs table (+ cron) for: auto-void, report generation, async follow-ups

Server-rendered views (EJS/Nunjucks + Tailwind) in dark mode with subtle animations

Updated workflow schematics
A) Global lifecycle
[Start]
-> Create PaymentIntent (or SetupIntent for PAD)
-> Confirmation (Elements | Terminal | Twilio Pay | PAD mandate)
-> AUTHORIZED (or REQUIRES_ACTION/PROCESSING/ASYNC)
-> CAPTURE (single) ---------> CAPTURED --> Receipt --> EOD Report
-> VOID (if not captured or manual)
-> TIMEOUT (4d18h job) -----> AUTO-VOID
-> FAILED/RETURNED --------------> Exceptions queue + EOD Report

B) CNP (web) – manual capture
UI form (no ZIP/3DS)
-> API: POST /api/intents {amount, currency: CAD, capture_method: manual}
-> Stripe Elements confirm
-> Status: requires_capture (AUTHORIZED)
-> Pending Auth page (countdown to 4d18h)
-> Capture once (<= authorized)
-> CAPTURED -> Receipt
-> Or Void
-> Or Auto-void at T+4d18h

C) Terminal Card / Interac (WisePOS E, Cloud)
UI "Take payment on terminal"
-> API: create PI (manual capture), create Connection Token
-> Present on reader (tap/insert)
-> Status: AUTHORIZED (or failed)
-> Pending Auth list
-> Single CAPTURE later -> Receipt (with signature if collected)
-> VOID or Auto-void at 4d18h
REFUNDS:
- Interac: from UI click "Refund on Reader"
-> Server drives WisePOS E refund flow (cardholder present)
- Other cards: API refund from UI

D) PAD (ACSS)
UI shows PAD mandate page (legal text + checkbox + IP/time capture)
-> Create/Attach payment_method (acss_debit) OR SetupIntent
-> Create/confirm PaymentIntent (async)
-> Webhooks update to SUCCEEDED or return code (NSF/REV/..)
-> Receipt on success; Returns go to DD Management + EOD exceptions

E) Twilio Pay (employee-initiated)
Agent triggers call from UI (Twilio <Pay> flow)
-> Customer enters card via DTMF (PCI handled by Twilio/Stripe)
-> Stripe creates/authorizes PI
-> On AUTHORIZED/SUCCEEDED:
- Store in DB + Receipt
- Send SMS to caller: "Authorized $[login to view URL], Locator: ABC123"
-> Add to Pending Auth (if manual capture) or mark captured if immediate

Pages & UX

Home (menu tiles)

Card Not Present (create → confirm → pending auth → capture/void)

Card Present / Interac (drive WisePOS E; live “processing” stepper)

Refunds (search transaction → refund; Interac button triggers reader)

Direct Debit (PAD) (mandate screen → debit status)

DD Management (mandates, debits, returns)

Twilio Pay (start call; show live status; auto-SMS on auth)

Pending Authorizations (filters, capture/void; countdowns)

Receipts (HTML/PDF; signature for CP)

Reports (EOD list with CSV/PDF)

API surface (server)

POST /api/intents → create PI (manual capture by default for CNP/Terminal)

POST /api/intents/:id/capture → single capture; enforce limits

POST /api/intents/:id/void

POST /api/refunds → non-Interac API refunds

POST /api/terminal/refunds → Interac refund on reader (server-driven)

POST /api/pad/mandates → persist acceptance artifacts

POST /api/pad/debits → create/confirm PI for ACSS

POST /api/twilio/webhook → call/payment events (create tx, send SMS)

POST /api/stripe/webhook → PaymentIntent/Charge/Refund/Terminal/PAD events

POST /api/reports/eod → generate on schedule (also via cron)

GET /api/transactions / GET /api/transactions/:id

GET /api/reports/:date → download CSV/PDF

Data model (MySQL – core tables)

transactions(id, type['card','interac','pad','twilio'], amount, currency, status['authorized','captured','voided','refunded','failed'], stripe_pi, stripe_charge, auth_code, reader_id, channel['cnp','terminal','twilio','pad'], created_at, updated_at)

preauthorizations(id, transaction_id, amount_authorized, expires_at)

refunds(id, transaction_id, amount, status, method['api','terminal'], stripe_refund_id, created_at)

dd_mandates(id, customer_id, mandate_text_version, ip, user_agent, signed_at, status, stripe_mandate_id)

dd_payments(id, mandate_id, transaction_id, amount, status, return_code, initiated_at, settled_at)

twilio_calls(id, call_sid, from_number, to_number, status, payment_locator, amount_authorized, created_at)

receipts(id, transaction_id, url, created_at)

jobs(id, type, payload_json, run_at, attempts, status, last_error, created_at)

audit_logs(id, actor, action, subject_type, subject_id, metadata_json, created_at)

Webhooks you must handle

Stripe: payment_intent.*, charge.*, terminal.reader.* (refunds), mandate.*, payment_method.*, balance.*, payout.*

Twilio: call lifecycle + <Pay> outcome webhooks (secure with signature validation)

Scheduled jobs (cron + jobs table)

auto_void_authorizations: void any PI still requires_capture at T+4d18h

daily_settlement_report: 23:59 America/Toronto (close business day, aggregate by channel, include refunds/voids/returns; produce CSV + HTML/PDF)

async_reconciliation: optional pass over Stripe balance txns to attach fees/net

Compliance & security

Never handle raw PAN/CVV (Elements hosted fields / Terminal / Twilio Pay).

PAD mandates: store acceptance text, IP, timestamp; display copy to customer.

Sign/verify all webhooks; apply Stripe idempotency keys; encrypt secrets.

Receipts mask PAN and include approval code, network refs, timestamps.

Deployment notes (cPanel)

App via Application Manager (Passenger); [login to view URL] as entry

Force HTTPS (.htaccess + HSTS)

Cron entries for jobs (every minute or 10 minutes)

Static assets under /public, caching + gzip

Separate staging subdomain with Stripe/Twilio test keys

What’s configurable

Auto-void interval (default fixed to 4d18h)

EOD time zone & cut-off (fixed to 23:59 America/Toronto)

SMS template for Twilio notification (amount + locator)

Receipt branding (logo later; default clean dark print layout)" (client-provided description)