# Serverless

> Serverless computing architecture

- Skill: `ffsshhttiikk/serverless` (Agent Skill)
- Install (CLI): `npx skillmds@latest add ffsshhttiikk/serverless`
- Raw SKILL.md: https://api.skillmd.com/api/skills/ffsshhttiikk/serverless/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: DevOps & Infra
- License: MIT
- Author: ffsshhttiikk (https://skillmd.com/u/ffsshhttiikk)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/ffsshhttiikk/serverless

---


## What I do

- Design serverless architectures
- Build functions-as-a-service applications
- Implement event-driven systems
- Configure serverless databases and storage
- Optimize function performance and costs
- Build serverless CI/CD pipelines

## When to use me

- When building event-driven applications
- When scaling is unpredictable
- When minimizing operational overhead
- When implementing microservices
- When building data processing pipelines
- When creating APIs quickly

## Key Concepts

### AWS Lambda

```python
# Lambda handler
import json
import boto3

def lambda_handler(event, context):
    # Parse the event
    http_method = event['httpMethod']
    path = event['path']
    
    # Business logic
    if http_method == 'GET' and path == '/users':
        return {
            'statusCode': 200,
            'body': json.dumps({'users': []}),
            'headers': {'Content-Type': 'application/json'}
        }
    
    return {
        'statusCode': 404,
        'body': json.dumps({'error': 'Not found'})
    }

# Lambda layers for dependencies
# Layer structure:
# python/lib/python3.11/site-packages/
```

### Serverless Framework

```yaml
# serverless.yml
service: my-serverless-app

provider:
  name: aws
  runtime: python3.11
  stage: ${opt:stage, 'dev'}
  region: ${opt:region, 'us-east-1'}
  
  environment:
    TABLE_NAME: !Ref UsersTable
    STRIPE_KEY: ${env:STRIPE_KEY}
    
  iam:
    role:
      statements:
        - Effect: Allow
          Action:
            - dynamodb:Query
            - dynamodb:Scan
          Resource: !GetAtt UsersTable.Arn

functions:
  users:
    handler: handler.get_users
    events:
      - http:
          path: /users
          method: get
          cors: true
      - http:
          path: /users/{userId}
          method: get
          cors: true
          
  processOrder:
    handler: handler.process_order
    events:
      - sqs:
          arn: !GetAtt OrdersQueue.Arn
          batchSize: 10
          
  uploadHandler:
    handler: handler.handle_upload
    events:
      - s3:
          bucket: uploads-${self:provider.stage}
          event: s3:ObjectCreated:*
          rules:
            - prefix: images/

resources:
  Resources:
    UsersTable:
      Type: AWS::DynamoDB::Table
      Properties:
        TableName: users-${self:provider.stage}
        BillingMode: PAY_PER_REQUEST
        AttributeDefinitions:
          - AttributeName: userId
            AttributeType: S
        KeySchema:
          - AttributeName: userId
            KeyType: HASH
```

### Azure Functions

```javascript
// Azure Function with triggers
module.exports = async function (context, req) {
    context.log('JavaScript HTTP trigger function processed a request.');
    
    const name = (req.query.name || (req.body && req.body.name));
    
    if (name) {
        context.res = {
            status: 200,
            body: { message: `Hello, ${name}` }
        };
    } else {
        context.res = {
            status: 400,
            body: { error: "Please pass a name" }
        };
    }
};

// bindings.json
{
  "bindings": [
    {
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "authLevel": "function"
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    }
  ]
}
```

### GCP Cloud Functions

```javascript
// Cloud Function 2nd Gen
const { CloudEvent, CloudFunction } = require('@google-cloud/functions-framework');

exports.processEvent = CloudEvent(async (cloudEvent) => {
  const data = cloudEvent.data;
  
  console.log('Event ID:', cloudEvent.id);
  console.log('Event Type:', cloudEvent.type);
  console.log('Data:', data);
  
  // Process the event
  await processData(data);
  
  return { success: true };
});

// HTTP Function
exports.httpFunction = async (req, res) => {
  const name = req.query.name || req.body.name || 'World';
  res.send(`Hello, ${name}!`);
};
```

### Event-Driven Architecture

```
┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│    S3       │────►│   Lambda    │────►│   DynamoDB  │
│  (Upload)    │     │  (Process)  │     │   (Store)   │
└─────────────┘     └─────────────┘     └─────────────┘
                          │
                          ▼
                   ┌─────────────┐
                   │    SNS     │
                   │  (Notify)  │
                   └─────────────┘
```

### Serverless Databases

```python
# AWS DynamoDB access
import boto3
from boto3.dynamodb.conditions import Key

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('users')

def get_user(user_id):
    response = table.get_item(Key={'user_id': user_id})
    return response.get('Item')

def query_users_by_org(org_id):
    response = table.query(
        KeyConditionExpression=Key('org_id').eq(org_id)
    )
    return response['Items']
```

### Cold Start Mitigation

- Provisioned concurrency
- Keep functions warm with scheduled invocations
- Use lighter dependencies
- Minimize function code size
- Pre-compile dependencies
- Use ARM/Graviton2 for better performance

### Cost Optimization

- Right-size memory allocation
- Use reserved capacity
- Optimize execution time
- Remove unnecessary dependencies
- Use native libraries instead of AWS SDK
- Batch operations where possible