DevOps for Fintech — AWS and Azure in Production

Fintech DevOps Is Different

Standard DevOps practices get you 80% of the way in fintech. The remaining 20% — regulatory compliance, data residency requirements, financial audit trails, and zero-tolerance for data loss — is what separates a production fintech platform from a regular web application.

Here's how we structure infrastructure for platforms handling real money across multiple jurisdictions.

Infrastructure Architecture

A typical fintech platform deployment:

┌─────────────────────────────────────┐
│           CloudFlare / WAF          │
└────────────────┬────────────────────┘
                 │
┌────────────────┴────────────────────┐
│         Load Balancer (ALB)         │
└────────────────┬────────────────────┘
                 │
    ┌────────────┼────────────────┐
    │            │                │
┌───┴───┐  ┌────┴────┐  ┌───────┴──┐
│  Web  │  │   API   │  │    WS    │
│ (ECS) │  │  (ECS)  │  │ Gateway  │
└───┬───┘  └────┬────┘  └───────┬──┘
    │           │               │
    └───────────┼───────────────┘
                │
    ┌───────────┼───────────────┐
    │           │               │
┌───┴───┐  ┌───┴────┐  ┌──────┴──┐
│  RDS  │  │ Redis  │  │   S3    │
│(Multi)│  │Cluster │  │(Encrypt)│
└───────┘  └────────┘  └─────────┘

We use ECS Fargate for containerized services — no server management, auto-scaling built in. For Azure deployments, the equivalent is AKS with managed node pools.

CI/CD Pipeline

Every merge to main triggers a pipeline that's more than just build-and-deploy:

# GitLab CI pipeline
stages:
  - test
  - security
  - build
  - deploy-staging
  - approval
  - deploy-production

test:
  stage: test
  script:
    - composer install
    - php artisan test --parallel
    - npm run test

security-scan:
  stage: security
  script:
    - trivy image $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
    - composer audit
    - npm audit

deploy-production:
  stage: deploy-production
  when: manual
  script:
    - aws ecs update-service --force-new-deployment
  environment:
    name: production

Key principles:

• Security scanning is mandatory in the pipeline — dependency vulnerabilities, container image scanning, and SAST
• Production deployments are manual — always require human approval
• Blue-green deployments — zero downtime, instant rollback capability
• Database migrations run separately from application deployments

Database Strategy

Financial data demands special handling:

Multi-AZ RDS with read replicas. The primary handles writes, read replicas serve dashboard queries and reporting. Failover is automatic:

Primary (us-east-1a) ──▶ Replica (us-east-1b)
                        ──▶ Replica (us-east-1c) [reporting]

Point-in-time recovery enabled. We maintain 35 days of backup retention with the ability to restore to any second. For fintech, this is not optional — regulators may require transaction reconstruction.

Encryption at rest and in transit. All RDS instances use AES-256 encryption. Connections require SSL. This is table stakes for financial services compliance.

Separate databases per concern:

• crm — client data, KYC records, IB hierarchies
• trading — trades, positions, commission calculations
• payments — deposits, withdrawals, PSP transactions
• audit — immutable audit trail of all operations

Secrets Management

Never store credentials in environment files or code. Use AWS Secrets Manager or Azure Key Vault:

// Fetched at runtime, cached for the request lifecycle
$dbPassword = app(SecretManager::class)->get('production/database/password');
$pspApiKey = app(SecretManager::class)->get('production/psp/stripe-key');

Secrets rotate on a schedule. The application fetches the current secret at startup and caches it. When rotation happens, the next deployment picks up the new value.

Monitoring Stack

Financial platforms need aggressive monitoring:

• New Relic for application performance — query times, error rates, throughput
• CloudWatch for infrastructure — CPU, memory, disk, network
• Custom dashboards for business metrics — deposits/hour, trade volume, commission payouts
• PagerDuty for alerting — critical issues page the on-call engineer

Key alerts:

• Payment webhook processing time > 5 seconds
• Database connection pool > 80% utilization
• Error rate > 1% on any API endpoint
• Queue depth growing for > 5 minutes
• SSL certificate expiring within 30 days

Data Residency and Compliance

Different jurisdictions have different rules about where data can live:

• EU clients — GDPR requires data processing agreements, right to deletion
• CySEC regulated brokers — data must be accessible for regulatory audits
• ASIC regulated — Australian client data may need to stay in-region

We handle this with tenant-aware routing at the infrastructure level. Each regulatory jurisdiction gets its own database cluster, and the application routes queries based on the client's regulatory entity.

Disaster Recovery

For fintech, the question isn't "if" something fails but "when":

• RTO (Recovery Time Objective): < 15 minutes for all services
• RPO (Recovery Point Objective): < 1 minute for financial data (continuous replication)
• Quarterly DR drills — actually fail over to the secondary region and verify everything works

Automated runbooks handle the most common failure scenarios:

1. Primary database failure → automatic failover to Multi-AZ standby
2. Application crash → ECS auto-restart + auto-scaling
3. Region failure → Route 53 health check triggers DNS failover

Key Takeaways

1. Blue-green deployments with manual production approval — zero downtime, instant rollback
2. Separate databases by concern — CRM, trading, payments, and audit each get their own
3. Encrypt everything — at rest, in transit, and in backups
4. Monitor aggressively — both technical metrics and business metrics
5. Plan for compliance — data residency requirements drive infrastructure architecture
6. Test your disaster recovery — a DR plan that hasn't been tested is just a document

Fintech infrastructure is about trust. Your clients trust you with their money, and regulators trust you with their data. The infrastructure needs to earn and maintain that trust.