Aeion Platform vs AWS & Heroku

AWS's cost model is usage-based — you pay for what you use. For a multi-tenant SaaS platform running on AWS:

Monthly AWS costs for 500 tenants:

• RDS PostgreSQL (Multi-AZ): ~$0.345/GB-hour × 1,000 GB × 730 hours = $252,000/month
• EC2 instances for app servers: $0.10/instance-hour × 50 instances × 730 = $3,650/month
• S3 for backups: $0.023/GB × 50,000 GB = $1,150/month
• RDS snapshots (PITR storage): $0.90/GB × 10,000 GB = $9,000/month
• Data transfer: variable, but typically $2,000-$5,000/month
• Total: $268,000+/month just for AWS infrastructure

That's before you add:

• Build team to implement multi-tenant isolation (6 months, $300K)
• Build subscription management (Stripe integration + webhooks, 3 months, $150K)
• Build backup verification (weekly restore testing, 2 months, $100K)
• Build compliance reporting (SOC2 audit trail, 3 months, $150K)
• Ongoing maintenance of everything you built (1 engineer, $15K/month)

Aeion Platform: Included in Aeion OS platform fee. No per-tenant DB instances. No snapshot storage charges. No EC2 management.

The problem: In a multi-tenant SaaS, one tenant's bug shouldn't be able to take down another tenant's data. AWS provides raw compute and storage — you're responsible for building the isolation.

AWS's isolation model:

``` Per-tenant VPC (if you do it right): → Each tenant: separate VPC, separate subnet, separate SG, separate IAM role → 500 tenants = 500 VPCs × $0.045/VPC-hour = $16,425/month → Plus per-tenant RDS = $0.345/GB-hour × 1,000 GB × 500 = $173,500/month

Shared DB (if you cut corners): → All tenants in one DB → catastrophic data leakage risk → One misconfigured query → all 500 tenants see each other's data ```

Aeion Platform isolation model:

Per-tenant DB schema (PostgreSQL schema per tenant) → One database, 500 schemas → AeionContext automatically scopes all queries to tenantId → No cross-tenant data access possible → Cost: same as single-tenant, not 500x

This is why multi-tenant BaaS platforms exist. Building this yourself on AWS takes 6-12 months of engineering. Aeion Platform ships it on day one.

AWS RDS PITR:

• Enabled per-RDS instance ($0.023/GB for backup storage)
• Restore creates a new instance — you can't restore to the existing one
• Recovery time: 30-60 minutes for a 500GB database
• No selective table restore — full instance only
• No backup verification — you test it manually (if you remember)

Aeion Aegis PITR:

• pgBackRest (default) — runs continuously alongside Postgres for point-in-time recovery
• Customer-managed Postgres — also supported, for teams running their own external database
• Selective table restore — extract specific tables at a specific timestamp instead of restoring the whole instance
• Pre-restore safety snapshot — an automatic pg_dump is taken before any restore, so the restore itself is never a one-way door
• Recovery time: 5-15 minutes for a 500GB database
• Selective restore: specific tables at a specific second, not full instance
• Weekly restore-and-verify: automated, not manual

The Aegis advantage: Pick the affected tables and the exact second to roll back to, and Aegis extracts and merges just those tables into the target tenant's database — the rest of the database is never touched, so nothing else in production is disturbed by the restore.

AWS equivalent: You can't. RDS PITR restores the entire instance. If a bug corrupted 3 tables at 2:47 AM, AWS forces you to restore the full DB from the last backup — losing everything between the backup and 2:47 AM.

Building on AWS (with Stripe):

typescript // You'd need to build: const subscriptionService = new SubscriptionService(); await subscriptionService.onWebhook(stripeEvent); // → Which plan did they upgrade to? // → What entitlements does the new plan have? // → Update tenant config with new entitlements // → Emit platform.subscription.upgraded event // → Queue provisioning job to apply changes // → Send confirmation email // → Update billing records

This takes 3-4 months to build correctly. And you still need to handle:

• Trial expiry (daily cron)
• Cancellation (immediate vs end-of-period)
• Payment failure → dunning sequence
• Reactivation (resume suspended instances)
• Upgrade → downgrade → cross-grade flows

Aeion's subscription lifecycle service handles all of this natively:

• Upgrade a plan — one call updates the subscription record, grants the new plan's entitlements, emits an event, and queues the provisioning job that applies the change.
• Cancel a subscription — one call sets it to cancel at the end of the current billing period (or immediately, if requested); provisioning automatically suspends the instance when the period ends.
• Reactivate — one call clears the cancellation flags and resumes any suspended instances.

Heroku Teams: $25/user/month. At 100 users: $2,500/month. At 500 users: $12,500/month. At 5,000 users: $125,000/month.

Heroku doesn't have:

• Multi-tenant isolation (it's per-app, not per-tenant)
• Subscription management (you manage billing yourself via Stripe)
• VPS provisioning (it's managed — you can't bring your own cloud)
• PITR (Heroku Postgres has point-in-time restore but it's basic)
• Compliance reporting (no SOC2/ISO27001 reporting built-in)
• Tenant notifications (no built-in alert system)
• Real-time tier management (Heroku Pipelines ≠ real-time call management)

If you need multi-tenant infrastructure (managing 50+ customer accounts, each with their own data, billing, and provisioning), Heroku's team model doesn't help. You still need everything that Aeion Platform provides — you just have to build it on top of Heroku, adding to the cost.

SOC2 and ISO27001 require evidence of:

• Backups running on schedule
• Backup restore tested periodically
• Retention policies enforced
• Audit logs retained for required period
• Incident response documented

AWS provides: Raw storage and compute. You build the evidence package yourself. An auditor reviewing your AWS setup needs:

1. Access to your AWS account (security risk)
2. Manual extraction of backup logs from CloudWatch
3. Manual verification of S3 lifecycle policies
4. Manual testing of restore procedures
5. Manual compilation of all evidence into a report

Aeion Platform: generates the evidence package automatically. Monthly HTML/JSON reports uploaded to S3 alongside backups. Auditors get pre-signed URLs — no AWS account access needed.

Automated backup verification: Weekly restore-and-verify runs automatically. Results go into the compliance report. "Untested backups are not backups" — this closes the gap that trips up most SOC2 audits.

The problem with no auto-upgrade: A tenant on a 2,000-call-minute plan runs a 3-hour all-hands (1,800 minutes). They have 200 minutes left. At the current rate, the meeting gets cut off 10 minutes before it ends. The tenant is frustrated. They're considering switching to a competitor.

Real-time auto-upgrade:

```typescript // Monitors usage at 5-minute intervals // When usage hits 80% of limit: // → Auto-upgrade to next plan tier // → Notify tenant (email + slack + webhook) // → Do NOT interrupt the current session

// Prevents bill shock and tenant churn // Tenants are grateful when their meeting doesn't cut off ```

AWS equivalent: You build this yourself. CloudWatch alarms → SNS → Lambda → Stripe API → upgrade plan. Plus you need to handle the edge cases (what if upgrade fails? what if tenant already at max plan? what if they're mid-session?).

The Aeion Platform advantage: It's built into the real-time module. Plan entitlements include realtime.maxCallMinutes and realtime.autoUpgradeThreshold. The service reads the config and handles the rest.