aws-patterns
Lambda best practices, S3 event patterns, SQS/SNS fanout, and DynamoDB access patterns for serverless AWS architectures.
Install / Use
npx skills add vibeeval/vibecosystem --skill aws-patternsInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
Content & MediaSupported Platforms
Our assessment of aws-patterns
aws-patterns scores 84/100 on our quality scale, 882nd of 1,148 Content & Media skills we index.
Its SKILL.md is 6.0 KB long, split into 7 sections with 4 code examples: a thorough specification that gives an agent plenty to work with.
It has 535 GitHub stars, a meaningful sign that others use it.
Maintenance, license and trust
- The repository was last updated about 3 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
- Our last check on 2026-10-10 found the source still online.
- It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 98/100, with no cautions. These come from repository metadata, not a code audit โ read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-10-04. Automated pattern scan on 2026-10-04. It catches known dangerous patterns, not every risk โ read a skill before letting an agent act on it.
aws-patterns compared with similar skills
All 4 of these similar skills score higher than aws-patterns; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| aws-patterns (this skill)by vibeeval | 84 | 535 | 3mo ago | SKILL.md |
| hyperframesby heygen-com | 100 | 86.4k | today | CLAUDE.md |
| rufloby ruvnet | 100 | 82.0k | today | CLAUDE.md |
| headroomby headroomlabs-ai | 100 | 80.1k | today | CLAUDE.md |
| siyuanby siyuan-note | 100 | 47.3k | today | MCP Server |
Frequently asked questions
- How do I install aws-patterns?
- Run
npx skills add vibeeval/vibecosystem --skill aws-patterns. The install tabs above show the steps for each supported agent. - Which AI agents does aws-patterns work with?
- It is written for Zed, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is aws-patterns safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 98/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is aws-patterns still maintained?
- The repository was last updated about 3 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
Skill content
View source on GitHubname: aws-patterns description: Lambda best practices, S3 event patterns, SQS/SNS fanout, and DynamoDB access patterns for serverless AWS architectures.
AWS Patterns
Serverless and managed service patterns for AWS production workloads.
Lambda Best Practices
// Cold start optimization: keep handler thin, initialize outside handler
import { DynamoDBClient } from '@aws-sdk/client-dynamodb'
import { DynamoDBDocumentClient, GetCommand } from '@aws-sdk/lib-dynamodb'
// Initialized ONCE per container (reused across invocations)
const client = DynamoDBDocumentClient.from(new DynamoDBClient({}))
export const handler = async (event: APIGatewayProxyEvent) => {
try {
const userId = event.pathParameters?.id
if (!userId) {
return { statusCode: 400, body: JSON.stringify({ error: 'Missing user ID' }) }
}
const result = await client.send(new GetCommand({
TableName: process.env.USERS_TABLE!,
Key: { pk: `USER#${userId}`, sk: `PROFILE` }
}))
if (!result.Item) {
return { statusCode: 404, body: JSON.stringify({ error: 'User not found' }) }
}
return {
statusCode: 200,
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(result.Item)
}
} catch (err) {
console.error('Handler error:', err)
return { statusCode: 500, body: JSON.stringify({ error: 'Internal server error' }) }
}
}
S3 Event Processing
// S3 โ Lambda: process uploaded files
import { S3Client, GetObjectCommand } from '@aws-sdk/client-s3'
const s3 = new S3Client({})
export const handler = async (event: S3Event) => {
for (const record of event.Records) {
const bucket = record.s3.bucket.name
const key = decodeURIComponent(record.s3.object.key.replace(/\+/g, ' '))
const size = record.s3.object.size
// Guard: skip non-image files or oversized uploads
if (size > 10_000_000) {
console.warn(`Skipping oversized file: ${key} (${size} bytes)`)
continue
}
const response = await s3.send(new GetObjectCommand({ Bucket: bucket, Key: key }))
const body = await response.Body!.transformToByteArray()
await processImage(body, key)
console.log(`Processed ${key} (${size} bytes)`)
}
}
SQS/SNS Fanout Pattern
// SNS โ multiple SQS queues (fanout to parallel consumers)
// Publisher: send to SNS topic
import { SNSClient, PublishCommand } from '@aws-sdk/client-sns'
const sns = new SNSClient({})
async function publishOrderEvent(order: Order): Promise<void> {
await sns.send(new PublishCommand({
TopicArn: process.env.ORDER_EVENTS_TOPIC!,
Message: JSON.stringify(order),
MessageAttributes: {
eventType: { DataType: 'String', StringValue: 'order.created' },
region: { DataType: 'String', StringValue: order.region }
}
}))
}
// Consumer: SQS Lambda (one per subscriber: email, analytics, inventory)
export const emailHandler = async (event: SQSEvent) => {
for (const record of event.Records) {
const order = JSON.parse(record.body) as Order
try {
await sendOrderConfirmation(order)
} catch (err) {
console.error(`Failed to send email for order ${order.id}:`, err)
throw err // Message returns to queue for retry (DLQ after maxReceiveCount)
}
}
}
DynamoDB Single-Table Design
// Access patterns drive table design, not entity relationships
// Table: pk (partition key) + sk (sort key) + GSI1PK + GSI1SK
// Entities: User, Order, OrderItem - all in one table
const AccessPatterns = {
// Get user profile
getUserProfile: (userId: string) => ({
pk: `USER#${userId}`,
sk: `PROFILE`
}),
// Get user's orders (sorted by date)
getUserOrders: (userId: string) => ({
pk: `USER#${userId}`,
sk: { begins_with: 'ORDER#' } // sk: ORDER#2025-01-15#orderId
}),
// Get order with items
getOrderWithItems: (orderId: string) => ({
pk: `ORDER#${orderId}`,
sk: { begins_with: '' } // sk: METADATA, ITEM#productId
}),
// Get orders by status (GSI1)
getOrdersByStatus: (status: string) => ({
GSI1PK: `STATUS#${status}`,
GSI1SK: { begins_with: '' } // GSI1SK: date#orderId
})
}
// Write: transactional multi-item write
import { TransactWriteCommand } from '@aws-sdk/lib-dynamodb'
async function createOrder(order: Order): Promise<void> {
const items = [
// Order metadata
{
Put: {
TableName: process.env.TABLE!,
Item: {
pk: `ORDER#${order.id}`,
sk: 'METADATA',
GSI1PK: `STATUS#${order.status}`,
GSI1SK: `${order.createdAt}#${order.id}`,
...order
}
}
},
// User's order reference
{
Put: {
TableName: process.env.TABLE!,
Item: {
pk: `USER#${order.userId}`,
sk: `ORDER#${order.createdAt}#${order.id}`,
orderId: order.id,
total: order.total,
status: order.status
}
}
}
]
await client.send(new TransactWriteCommand({ TransactItems: items }))
}
Checklist
- [ ] Lambda: initialize SDK clients outside handler (reuse across invocations)
- [ ] Lambda: set memory based on profiling (more memory = more CPU = faster)
- [ ] Lambda: set timeout to 2x expected duration (not max 900s)
- [ ] SQS: configure Dead Letter Queue with maxReceiveCount: 3
- [ ] DynamoDB: design table around access patterns, not entities
- [ ] DynamoDB: use TransactWrite for multi-item atomicity
- [ ] S3: enable versioning and lifecycle rules for cost optimization
- [ ] SNS: use message attributes for subscriber filtering
Anti-Patterns
- Initializing SDK clients inside Lambda handler (cold start penalty every time)
- Synchronous Lambda chains: A calls B calls C (use Step Functions)
- DynamoDB scan operations in production (always query with pk/sk)
- S3 event without idempotency: Lambda can be invoked multiple times per event
- Oversized Lambda packages (>50MB): use layers or container images
- Missing DLQ on SQS: failed messages silently disappear after retention period
Related Skills
hyperframes
86.4kAI video you can actually edit. HyperFrames is a free, open-source AI video editor. Describe any video and get a real project you can change down to the frame.
ruflo
82.0k๐ The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
headroom
80.1kCompress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
siyuan
47.3kAn open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together ๅผๆบใ้็งไผๅ ใ่ชๆ็ฎก็็ฅ่ฏๅทฅไฝ็ฉบ้ด๏ผ่ฎฉไบบไธๆบ่ฝไฝๅจๆญคๅไฝ
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit โ see the Safety scan above for what the skill file itself contains.
