Cloud Computing Applications in Fintech: Real-World Examples

import sqlite3

db = sqlite3.connect("payments.db")
db.execute("""CREATE TABLE IF NOT EXISTS payments (
    request_id TEXT PRIMARY KEY,
    amount INTEGER NOT NULL,
    status TEXT NOT NULL)""")

def process(request_id: str, amount: int) -> str:
    """Process a payment once, even if the request is retried."""
    try:
        db.execute("INSERT INTO payments VALUES (?, ?, 'DONE')",
                   (request_id, amount))
        db.commit()
        return "processed"
    except sqlite3.IntegrityError:
        return "duplicate ignored"

print(process("req-101", 500))
print(process("req-101", 500))   # retry -> duplicate ignored

# pip install boto3
import json
import boto3

sqs = boto3.client("sqs", region_name="ap-south-1")
QUEUE_URL = "https://sqs.ap-south-1.amazonaws.com/123456789012/payments"

while True:
    resp = sqs.receive_message(QueueUrl=QUEUE_URL,
                               MaxNumberOfMessages=10,
                               WaitTimeSeconds=20)
    for msg in resp.get("Messages", []):
        body = json.loads(msg["Body"])
        print("processing", body["request_id"])
        # call process(body["request_id"], body["amount"]) here
        sqs.delete_message(QueueUrl=QUEUE_URL,
                           ReceiptHandle=msg["ReceiptHandle"])

resource "aws_s3_bucket" "kyc_docs" {
  bucket = "example-kyc-docs-ap-south-1"
}

resource "aws_s3_bucket_public_access_block" "kyc_docs" {
  bucket                  = aws_s3_bucket.kyc_docs.id
  block_public_acls       = true
  block_public_policy     = true
  ignore_public_acls      = true
  restrict_public_buckets = true
}

resource "aws_s3_bucket_server_side_encryption_configuration" "kyc_docs" {
  bucket = aws_s3_bucket.kyc_docs.id
  rule {
    apply_server_side_encryption_by_default {
      sse_algorithm = "aws:kms"
    }
  }
}

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "ReadKycDocsOnly",
      "Effect": "Allow",
      "Action": ["s3:GetObject"],
      "Resource": "arn:aws:s3:::example-kyc-docs-ap-south-1/*"
    }
  ]
}

#!/usr/bin/env bash
# Inspect resilience settings of an RDS database (read-only)
DB=payments-db

aws rds describe-db-instances --db-instance-identifier "$DB" \
  --query 'DBInstances[0].{MultiAZ:MultiAZ,Backups:BackupRetentionPeriod,Encrypted:StorageEncrypted}' \
  --output table

# List recent automated snapshots
aws rds describe-db-snapshots --db-instance-identifier "$DB" \
  --snapshot-type automated \
  --query 'DBSnapshots[-3:].[DBSnapshotIdentifier,SnapshotCreateTime]' \
  --output table

Restore drill runbook (practice account only)

1. Pick the latest automated snapshot
2. Restore it to a NEW instance name (never overwrite)
3. Connect and run sanity queries:
   - row counts of key tables
   - latest transaction timestamp
4. Record time taken and any problems
5. Delete the drill instance to avoid cost
6. Update the runbook with lessons learned

Project: Mini wallet backend on cloud (dummy data)

Components:
- API behind a load balancer (2 instances / containers)
- Payment requests sent to a queue
- Worker with idempotent processing
- Encrypted database in private subnets
- Encrypted storage bucket for statements
- Logs and one alarm on error rate

[ ] No public access to database or bucket
[ ] Encryption at rest enabled everywhere
[ ] IAM roles follow least privilege
[ ] Duplicate request test passes
[ ] Load test shows scaling
[ ] Restore drill completed and documented
[ ] Billing alarm and resource tags set
[ ] Everything defined in Terraform

# Mini Wallet Cloud Backend

## Problem
Handle payment bursts safely without double charges.

## Architecture
(diagram + one line per component)

## Security decisions
Encryption, IAM, private networking.

## Resilience
Multi-AZ choice, backup and restore drill results.

## Cost
What it costs to run and how to tear it down.