Architecture Paradigm Serverless Skill for Claude

Applies serverless FaaS patterns for event-driven workloads. Use when designing bursty workloads with minimal infrastructure and pay-per-execution cost model.

1k tokens

context cost

the whole folder, loaded on every use

files

instructions only

copies elsewhere

how many repositories repackaged it

324

stars on the repo

on the repository, not the skill itself

Install

one command, takes just this skill from the repository

npx skills add https://github.com/athola/claude-night-market --skill architecture-paradigm-serverless

The instruction itself

9 sections, as written by the author

The Serverless Architecture Paradigm

When To Use

Event-driven workloads with variable traffic
Minimizing operational overhead for cloud-native apps

When NOT To Use

Long-running processes exceeding function timeout limits
Applications requiring persistent connections or local state

When to Employ This Paradigm

When workloads are event-driven and exhibit intermittent or "bursty" traffic patterns.
When the goal is to minimize infrastructure management and adopt a pay-per-execution cost model.
When latency constraints from "cold starts" are acceptable for the use case or can be effectively mitigated.

Adoption Steps

Identify Functions: Decompose workloads into small, stateless function handlers triggered by events such as HTTP requests, message queues, or scheduled timers.
Externalize State: use managed services like databases and queues for all persistent state. Design handlers to be idempotent to validate that repeated executions do not have unintended side effects.
Plan Cold-Start Mitigation: For latency-sensitive paths, keep function dependencies minimal. Employ strategies such as provisioned concurrency or "warmer" functions to reduce cold-start times.
Implement Instrumentation and Security: Enable detailed tracing and logging for all functions. Adhere to the principle of least privilege with IAM roles and set per-function budgets to control costs.
Automate Deployment: Use Infrastructure-as-Code (IaC) frameworks like SAM, CDK, or Terraform to create repeatable and reliable release processes.

Key Deliverables

An Architecture Decision Record (ADR) that describes function triggers, runtime choices, state management strategies, and cost projections.
A complete Infrastructure-as-Code (IaC) and CI/CD pipeline for automatically packaging and deploying functions.
Observability dashboards to monitor key metrics including function duration, error rates, cold-start frequency, and cost.

Risks & Mitigations

Vendor Lock-in:
Mitigation: Where feasible, abstract away provider-specific APIs behind your own interfaces or adopt portable frameworks (e.g., Serverless Framework) to reduce dependency on a single cloud vendor.
Debugging Challenges:
Mitigation: Tracing execution across distributed functions can be complex. Standardize on specific instrumentation libraries and structured logging to simplify debugging.
Resource Limits:
Mitigation: Actively monitor provider-imposed limits, such as concurrency and memory quotas. Design workloads to be shardable or horizontally scalable to stay within these constraints.

Concrete Components

These vocabulary items name the concrete tools and abstractions

that show up when the paradigm is implemented. They are not

required dependencies and they are not part of the skill's

tools: frontmatter (which is reserved for Claude Code tool

restrictions). Use this list to disambiguate during architecture

discussions.

cloud-sdk: AWS SDK, Google Cloud SDK, or Azure SDK; first-class platform integration
serverless-framework: Serverless Framework, SAM, or CDK; declarative function deployment
IaC-tools: Terraform, Pulumi, or platform-native IaC for shared infrastructure around functions

Exit Criteria

[ ] An ADR documents function triggers, runtime choices, state externalization strategy,

cold-start mitigation approach, and cost projections before any function is deployed.

[ ] A complete IaC definition (SAM, CDK, Terraform, or equivalent) exists for every function

and its supporting infrastructure, enabling repeatable deploys from scratch.

[ ] Every function handler is idempotent: repeated execution with the same event produces the

same outcome and no duplicate side effects (verified by unit test with replayed inputs).

[ ] Observability dashboards cover function duration, error rate, cold-start frequency, and

cost per invocation before the function reaches production traffic.

Other skills for the same job

different authors, same section of the catalogue

Azure Kubernetes Automatic Readiness

by microsoft

vendor ×3

Assess Kubernetes workloads and cluster configuration for AKS Automatic compatibility. Identifies incompatibilities, generates fixes, and guides migration from AKS Standard to AKS Automatic. WHEN: migrate to AKS Automatic, check AKS Automatic readiness, validate manifests for Automatic, assess cluster for Automatic compatibility, fix deployment for Automatic compatibility, identify AKS Automatic migration blockers, is my cluster ready for AKS Automatic.

Discovers available Azure OpenAI model capacity across regions and projects. Analyzes quota limits, compares availability, and recommends optimal deployment locations based on capacity requirements. USE FOR: find capacity, check quota, where can I deploy, capacity discovery, best region for capacity, multi-project capacity search, quota analysis, model availability, region comparison, check TPM availability. DO NOT USE FOR: actual deployment (hand off to preset or customize after discovery), quota increase requests (direct user to Azure Portal), listing existing deployments.

Interactive guided deployment flow for Azure OpenAI models with full customization control. Step-by-step selection of model version, SKU (GlobalStandard/Standard/ProvisionedManaged), capacity, RAI policy (content filter), and advanced options (dynamic quota, priority processing, spillover). USE FOR: custom deployment, customize model deployment, choose version, select SKU, set capacity, configure content filter, RAI policy, deployment options, detailed deployment, advanced deployment, PTU deployment, provisioned throughput. DO NOT USE FOR: quick deployment to optimal region (use preset).

Unified Azure OpenAI model deployment skill with intelligent intent-based routing. Handles quick preset deployments, fully customized deployments (version/SKU/capacity/RAI policy), and capacity discovery across regions and projects. USE FOR: deploy model, deploy gpt, create deployment, model deployment, deploy openai model, set up model, provision model, find capacity, check model availability, where can I deploy, best region for model, capacity analysis. DO NOT USE FOR: listing existing deployments (use foundry_models_deployments_list MCP tool), deleting deployments, agent creation (use agent/create), project creation (use project/create).

Intelligently deploys Azure OpenAI models to optimal regions by analyzing capacity across all available regions. Automatically checks current region first and shows alternatives if needed. USE FOR: quick deployment, optimal region, best region, automatic region selection, fast setup, multi-region capacity check, high availability deployment, deploy to best location. DO NOT USE FOR: custom SKU selection (use customize), specific version selection (use customize), custom capacity configuration (use customize), PTU deployments (use customize).

This skill should be used when working with LaminDB, an open-source data framework for biology that makes data queryable, traceable, reproducible, and FAIR. Use when managing biological datasets (scRNA-seq, spatial, flow cytometry, etc.), tracking computational workflows, curating and validating data with biological ontologies, building data lakehouses, or ensuring data lineage and reproducibility in biological research. Covers data management, annotation, ontologies (genes, cell types, diseases, tissues), schema validation, integrations with workflow managers (Nextflow, Snakemake) and MLOps platforms (W&B, MLflow), and deployment strategies.

Latch platform for bioinformatics workflows. Build pipelines with Latch SDK, @workflow/@task decorators, deploy serverless workflows, LatchFile/LatchDir, Nextflow/Snakemake integration.

Run Python code in the cloud with serverless containers, GPUs, and autoscaling. Use when deploying ML models, running batch processing jobs, scheduling compute-intensive tasks, or serving APIs that require GPU acceleration or dynamic scaling.

17k tokens

How to use it

Copy the folder

Take athola/architecture-paradigm-serverless from the repository into ~/.claude/skills for personal use, or into .claude/skills inside a project.

Check the name does not clash

The agent identifies a skill by the name field in its header. Two skills with the same name cannot sit side by side — one of them will be ignored.