1
// This Lambda literally just runs a SQL query
2
exports.getUserById = async (event) => {
3
  const { userId } = event;
4
  const user = await db.query('SELECT * FROM users WHERE id = ?', [userId]);
5
  return user;
6
};
7
 
8
// What this should be: A function in your application
9
function getUserById(userId) {
10
  return db.query('SELECT * FROM users WHERE id = ?', [userId]);
11
}

1
# Lambda that exists only to change JSON structure
2
def transform_user_data(event, context):
3
    user = event['user']
4
    return {
5
        'id': user['user_id'],
6
        'name': user['first_name'] + ' ' + user['last_name'],
7
        'email': user['email_address']
8
    }
9
 
10
# Should be: A simple mapper function in your code
11
def transform_user(user):
12
    return {
13
        'id': user['user_id'],
14
        'name': user['first_name'] + ' ' + user['last_name'],
15
        'email': user['email_address']
16
    }

1
// Lambda A calls Lambda B calls Lambda C
2
exports.processOrder = async (event) => {
3
  // Step 1: Validate order
4
  const validation = await lambda.invoke({
5
    FunctionName: 'validate-order-lambda',
6
    Payload: JSON.stringify(event)
7
  });
8
  
9
  if (!validation.valid) return { error: 'Invalid order' };
10
  
11
  // Step 2: Calculate pricing
12
  const pricing = await lambda.invoke({
13
    FunctionName: 'calculate-pricing-lambda',
14
    Payload: JSON.stringify(validation.order)
15
  });
16
  
17
  // Step 3: Apply discounts
18
  const finalPrice = await lambda.invoke({
19
    FunctionName: 'apply-discounts-lambda',
20
    Payload: JSON.stringify(pricing)
21
  });
22
  
23
  return finalPrice;
24
};
25
 
26
// What you've built: A distributed monolith with network latency
27
// What you should have: Three function calls in the same process

1
# Using Lambda + DynamoDB to track multi-step processes
2
def update_workflow_step(event, context):
3
    workflow_id = event['workflowId']
4
    current_step = event['step']
5
    
6
    # Fetch current state from DynamoDB
7
    state = dynamodb.get_item(Key={'id': workflow_id})
8
    
9
    # Update to next step
10
    if current_step == 'started':
11
        state['step'] = 'processing'
12
    elif current_step == 'processing':
13
        state['step'] = 'completed'
14
    
15
    # Save back to DynamoDB
16
    dynamodb.put_item(Item=state)
17
    
18
    # Trigger next Lambda
19
    if state['step'] != 'completed':
20
        lambda.invoke(FunctionName='process-next-step', Payload=state)
21
 
22
# The irony: You've reimplemented a state machine... badly

1
// Lambda that exists to return configuration
2
exports.getConfig = async (event) => {
3
  return {
4
    apiUrl: process.env.API_URL,
5
    apiKey: process.env.API_KEY,
6
    environment: process.env.ENVIRONMENT
7
  };
8
};
9
 
10
// Calling this from another Lambda 🤦
11
const config = await lambda.invoke({
12
  FunctionName: 'get-config-lambda'
13
});

1
with db.transaction():
2
    # ALL of this succeeds or NONE of it does
3
    user.debit_balance(amount)
4
    merchant.credit_balance(amount)
5
    order = Order.create(user=user, merchant=merchant, amount=amount)
6
    inventory.reserve_items(order.items)
7
    send_order_confirmation(order)  # If this fails, everything rolls back

1
// Lambda Anti-Pattern: 5 functions, 5 ways to fail
2
// checkout-lambda → payment-lambda → inventory-lambda → order-lambda → email-lambda
3
 
4
// What happens:
5
// 1. Payment succeeds ✓
6
// 2. Inventory deduction fails ✗
7
// 3. Now what? Customer was charged but no items reserved
8
 
9
// Monolith Solution: One transaction
10
async function checkout(userId, items, paymentMethod) {
11
  const trx = await db.transaction();
12
  try {
13
    const order = await Order.create({ userId, items }, trx);
14
    await Inventory.reserve(items, order.id, trx);
15
    const payment = await Payment.charge(paymentMethod, order.total, trx);
16
    await order.update({ paymentId: payment.id }, trx);
17
    
18
    await trx.commit();
19
    // Only NOW do we send emails, after everything succeeded
20
    await EmailQueue.send('order_confirmation', order);
21
  } catch (error) {
22
    await trx.rollback();
23
    throw error; // Customer not charged, inventory not touched
24
  }
25
}

1
# Lambda: Each function sees a different database state
2
# transfer-init → debit-account → credit-account → notify-users
3
 
4
# Race condition: What if two transfers happen simultaneously?
5
# Function A reads balance: $100
6
# Function B reads balance: $100
7
# Function A debits $60: balance = $40
8
# Function B debits $60: balance = $40 (should be -$20!)
9
 
10
# Monolith: Row-level locking prevents this
11
def transfer_money(from_account_id, to_account_id, amount):
12
    with db.atomic():
13
        # SELECT ... FOR UPDATE locks the row
14
        sender = Account.select_for_update().get(id=from_account_id)
15
        if sender.balance < amount:
16
            raise InsufficientFunds()
17
        
18
        sender.balance -= amount
19
        sender.save()
20
        
21
        recipient = Account.get(id=to_account_id)
22
        recipient.balance += amount
23
        recipient.save()
24
        
25
        Transfer.create(
26
            from_account=sender,
27
            to_account=recipient,
28
            amount=amount
29
        )

1
# Lambda: Feature flags, billing, and emails as separate functions
2
# Each can fail independently, leaving customers in limbo
3
 
4
# Monolith: Atomic subscription updates
5
def change_subscription_plan(user, new_plan):
6
    with db.atomic():
7
        old_plan = user.subscription.plan
8
        
9
        # Calculate prorated charges
10
        proration = calculate_proration(old_plan, new_plan)
11
        
12
        # All of these happen together or not at all
13
        user.subscription.plan = new_plan
14
        user.subscription.save()
15
        
16
        # Update feature flags
17
        user.features.update(new_plan.features)
18
        
19
        # Adjust billing
20
        if proration > 0:
21
            charge = Charge.create(user=user, amount=proration)
22
        else:
23
            Credit.create(user=user, amount=abs(proration))
24
        
25
        # Create audit trail
26
        SubscriptionChange.create(
27
            user=user,
28
            from_plan=old_plan,
29
            to_plan=new_plan,
30
            proration=proration
31
        )
32
    
33
    # Only after successful commit
34
    send_plan_change_email(user, old_plan, new_plan)

1
// Two Lambda functions triggered by retry logic
2
// Both check if payment was processed, both see "no", both charge
3
 
4
// Lambda Function (runs twice due to retry):
5
async function processPayment(orderId) {
6
  const order = await getOrder(orderId);
7
  if (!order.paid) {
8
    // RACE CONDITION: Another Lambda might be doing this NOW
9
    const charge = await stripe.charge(order.amount);
10
    await markOrderPaid(orderId, charge.id);
11
  }
12
}
13
 
14
// Monolith: Unique constraints and transactions prevent this
15
async function processPayment(orderId) {
16
  const trx = await db.transaction();
17
  try {
18
    const order = await Order.findById(orderId).lock(trx);
19
    if (order.paid) return order;
20
    
21
    const charge = await stripe.charge(order.amount);
22
    order.chargeId = charge.id;
23
    order.paid = true;
24
    await order.save(trx);
25
    
26
    await trx.commit();
27
    return order;
28
  } catch (error) {
29
    await trx.rollback();
30
    if (error.code === 'UNIQUE_VIOLATION') {
31
      // Another process beat us to it, that's fine
32
      return Order.findById(orderId);
33
    }
34
    throw error;
35
  }
36
}

1
# Multiple Lambdas checking inventory simultaneously
2
# All see "5 items available", all sell 3 items
3
# Result: -4 inventory (you just sold items you don't have)
4
 
5
# Lambda: No way to lock across functions
6
def check_and_reserve_inventory(sku, quantity):
7
    available = get_inventory_count(sku)  # Returns 5
8
    # DANGER ZONE: 10 other Lambdas doing this right now
9
    if available >= quantity:
10
        update_inventory(sku, available - quantity)  # Sets to 2
11
        return True
12
    return False
13
 
14
# Monolith: Database constraints save you
15
def reserve_inventory(sku, quantity):
16
    with db.atomic():
17
        # This locks the row until transaction completes
18
        item = Inventory.select_for_update().get(sku=sku)
19
        if item.available >= quantity:
20
            item.available -= quantity
21
            item.save()
22
            return True
23
        return False
24
        # If constraint fails, database prevents negative inventory

1
// Trying to implement distributed transactions with compensating actions
2
// Order Saga: 8 Lambda functions just to handle failures
3
 
4
// 1. create-order-lambda
5
// 2. reserve-inventory-lambda
6
// 3. charge-payment-lambda
7
// 4. confirm-order-lambda
8
// If any fail:
9
// 5. cancel-order-lambda
10
// 6. release-inventory-lambda  
11
// 7. refund-payment-lambda
12
// 8. notify-failure-lambda
13
 
14
// Each compensation can also fail! Now you need:
15
// - Dead letter queues for failed compensations
16
// - Manual reconciliation processes
17
// - A team of people figuring out what went wrong
18
 
19
// Monolith equivalent: Just... don't commit the transaction

1
# Lambda can't participate in 2PC because:
2
# 1. Functions are stateless
3
# 2. Can't hold locks across invocations  
4
# 3. Coordinator can disappear between phases
5
# 4. Network partitions are common
6
 
7
# You end up building a distributed transaction coordinator
8
# Congrats, you just built a worse database

1
BEGIN;
2
  -- Check inventory
3
  UPDATE inventory SET count = count - 1 
4
  WHERE sku = '12345' AND count >= 1;
5
  
6
  -- Only continues if above succeeded
7
  INSERT INTO orders (user_id, sku, total) 
8
  VALUES (123, '12345', 99.99);
9
  
10
  -- Charge stored payment method
11
  INSERT INTO charges (order_id, amount, status) 
12
  VALUES (LASTVAL(), 99.99, 'pending');
13
  
14
  -- All succeed or all fail
15
COMMIT;

1
# Celery with autoscaling (handles 99% of "spiky" workloads)
2
# Worker count scales based on queue depth
3
CELERY_WORKER_AUTOSCALER = 'celery.worker.autoscale:Autoscaler'
4
CELERY_WORKER_AUTOSCALE_MAX = 10  # Scale up to 10 workers
5
CELERY_WORKER_AUTOSCALE_MIN = 2   # Keep 2 minimum
6
 
7
# Cost: ~$50-100/month for always-on workers
8
# Lambda equivalent: $500-2000/month for similar traffic

1
// Webhook with Lambda
2
exports.handler = async (event) => {
3
  // Process webhook, hope it doesn't fail
4
  // If it fails, good luck debugging CloudWatch
5
};
6
 
7
// Webhook with traditional queue
8
app.post('/webhooks/stripe', async (req, res) => {
9
  await queue.add('process-stripe-webhook', req.body);
10
  res.json({ received: true });
11
});
12
 
13
// Benefits: Retry logic, dead letter queues, local debugging
14
// Can inspect queue, replay failed jobs, test locally

1
# Lambda: Debugging monthly job that failed
2
# 1. Find the right CloudWatch log group
3
# 2. Search through logs from 3 weeks ago
4
# 3. Can't reproduce locally
5
# 4. Add more logging, wait a month
6
 
7
# Celery/Cron: Debugging monthly job
8
# 1. SSH into server
9
# 2. Run: python manage.py run_monthly_report --debug
10
# 3. Fix issue immediately

1
@celery.task
2
def sync_to_external_system(data):
3
    # Same code, but debuggable
4
    response = external_api.post(data)
5
    if response.error:
6
        # You can actually see this error
7
        raise RetryableError(response.error)

1
def create_user(params):
2
    user = User.create(**params)
3
    send_welcome_email.delay(user.id)  # Celery task
4
    Analytics.track_signup(user)
5
    user.create_default_preferences()
6
    return user

1
// Before: 8 Lambda functions, 3 SQS queues, EventBridge rules
2
// After: One background job processor
3
async function sendEmail(type, userId, data) {
4
  const user = await User.findById(userId);
5
  const html = await renderTemplate(type, { user, ...data });
6
  await mailgun.send({ to: user.email, html });
7
  await Analytics.track('email_sent', { type, userId });
8
}
9
 
10
// Queue it from anywhere in the app
11
await emailQueue.add('send', { type: 'welcome', userId, data });

1
# All processing in one job, one memory space
2
def process_image(image_id):
3
    image = Image.get(image_id)
4
    
5
    # Load once, process in memory
6
    img = PIL.Image.open(image.file)
7
    
8
    # All operations on the same image object
9
    if not validate_image(img):
10
        raise InvalidImageError()
11
    
12
    sizes = generate_sizes(img, [100, 300, 800])
13
    upload_to_cdn(sizes)
14
    
15
    # Single database transaction
16
    image.update(processed=True, sizes=sizes)

1
# Python with Celery beat scheduler
2
from celery.schedules import crontab
3
 
4
beat_schedule = {
5
    'cleanup-hourly': {
6
        'task': 'tasks.data_cleanup',
7
        'schedule': crontab(minute=0),  # Every hour
8
    },
9
    'daily-reports': {
10
        'task': 'tasks.generate_daily_reports',
11
        'schedule': crontab(hour=2, minute=0),  # 2:00 AM daily
12
    },
13
    'weekly-customer-reports': {
14
        'task': 'tasks.send_weekly_reports',
15
        'schedule': crontab(hour=9, minute=0, day_of_week=1),  # Mondays 9AM
16
    },
17
}

1
git clone
2
docker-compose up -d  # Just Postgres and Redis
3
pip install -r requirements.txt
4
python manage.py runserver

1
# Pick your poison
2
django-admin startproject recovery          # Python
3
rails new recovery-app                      # Ruby
4
npx create-next-app recovery                # JavaScript/TypeScript
5
dotnet new webapi -n recovery               # C#/.NET
6
spring init --name=recovery recovery        # Java/Spring Boot
7
cargo new recovery --bin                    # Rust
8
mix phx.new recovery                        # Elixir/Phoenix
9
composer create-project laravel/laravel recovery  # PHP/Laravel
10
go mod init recovery                        # Go

1
// Before: 7 Lambda functions
2
// After: One service class
3
class OrderService {
4
  async processOrder(userId, items, paymentMethod) {
5
    const trx = await db.transaction();
6
    try {
7
      // All the logic from 7 different Lambdas, now in one place
8
      const order = await this.createOrder(userId, items, trx);
9
      await this.reserveInventory(order, trx);
10
      const payment = await this.processPayment(order, paymentMethod, trx);
11
      await this.updateOrderStatus(order, 'paid', trx);
12
      
13
      await trx.commit();
14
      
15
      // Async operations that don't need immediate consistency
16
      this.emailQueue.send('order_confirmation', order);
17
      this.analytics.track('order_completed', order);
18
      
19
      return order;
20
    } catch (error) {
21
      await trx.rollback();
22
      throw error;
23
    }
24
  }
25
}

1
if (featureFlags.useMonolithOrderProcessing) {
2
  return orderService.processOrder(userId, items, paymentMethod);
3
} else {
4
  // Old Lambda invocation
5
  return lambda.invoke('process-order-lambda', { userId, items, paymentMethod });
6
}

1
// Before: EventBridge + Lambda for each scheduled job
2
// After: One cron service
3
class ScheduledJobs {
4
  @Cron('0 2 * * *')
5
  async dailyReports() {
6
    // Logic from daily-report-lambda
7
  }
8
  
9
  @Cron('0 * * * *')
10
  async hourlyCleanup() {
11
    // Logic from cleanup-lambda
12
  }
13
}

1
# Before: Lambda triggered by SQS
2
# After: Background job processor
3
@celery.task
4
def process_user_signup(user_id):
5
    user = User.get(user_id)
6
    send_welcome_email(user)
7
    create_default_settings(user)
8
    sync_to_analytics(user)

1
from django.core.cache import cache
2
from datetime import timedelta
3
 
4
class UserService:
5
    def get_user(self, user_id):
6
        cache_key = f"user:{user_id}"
7
        user = cache.get(cache_key)
8
        
9
        if user is None:
10
            user = User.objects.get(id=user_id)
11
            cache.set(cache_key, user, timeout=timedelta(minutes=5).seconds)
12
        
13
        return user

1
# docker-compose.yml or k8s config
2
services:
3
  app:
4
    image: your-app
5
    replicas: 3  # Start with 3, scale as needed
6
    environment:
7
      - DATABASE_URL=postgres://...
8
      - REDIS_URL=redis://...