AWS Builder Center

Building a Serverless AI Stand-Up Generator with Amazon Bedrock and AWS Lambda

Stand-Up Generator is a serverless AI application built on AWS Lambda and Amazon Bedrock (Claude 3 Haiku) that instantly transforms raw developer task notes into structured, copy-paste-ready daily scrum updates for Slack and Microsoft Teams eliminating the morning overhead of manual stand-up writing for software engineers.

I am a DevOps Engineer with 3+ YOE in IT Industry

Building a Serverless AI Stand-Up Generator with Amazon Bedrock and AWS Lambda

Tag:  #application   #aws-builder-showcase   #generative-ai   #serverless 

1. Executive Summary

In modern agile software development, daily stand-up meetings (scrum updates) are critical for maintaining team alignment, tracking progress, and surfacing operational blockers. However, manually drafting clear, well-structured updates across Slack or Microsoft Teams every morning creates small but cumulative cognitive friction for software engineers.
To streamline this daily ritual, Stand-Up Generator was built: a lightweight, serverless AI application that transforms raw developer task notes into structured, copy-paste-ready daily scrum updates in seconds. Built entirely on AWS serverless infrastructure, the application pairs a single-page frontend hosted on GitHub Pages with an AWS Lambda API layer that queries Amazon Bedrock (Claude 3 Haiku) to generate context-aware updates formatted according to user-selected tones.

2. Problem Statement & Motivation

Every morning, software engineers spend time context-switching between code editors, issue trackers, and messaging tools to construct their daily stand-up updates. Common challenges include:
  • Inconsistent Reporting: Updates vary significantly in structure, detail, and formatting across team members.
  • Context Overhead: Translating granular commit messages and ticket IDs into clear high-level summaries requires manual effort.
  • Tone Matching: Different audiences (engineering managers, cross-functional partners, or casual team Slack channels) require different presentation styles.
Stand-Up Generator eliminates this overhead by accepting simple, unformatted bullet points (what was completed yesterday, what is planned today, and active blockers) and passing them through a generative model engineered specifically for agile communication.

3. System Architecture & AWS Services

The application follows an event-driven, decoupled serverless architecture designed for minimal latency, high availability, and near-zero operating costs.
┌─────────────────────────┐ HTTPS POST ┌──────────────────────────────┐
│ GitHub Pages Frontend │ ───────────────────────► │ AWS Lambda Function URL │
│ (Vanilla HTML/CSS/JS) │ ◄─────────────────────── │ (Python 3.12 Runtime Environment) │
└─────────────────────────┘ JSON Response └──────────────┬───────────────┘
│
│ Boto3 SDK
▼
┌──────────────────────────────┐
│ Amazon Bedrock │
│ (Anthropic Claude 3 Haiku) │
└──────────────────────────────┘

AWS Component Breakdown:

  1. Amazon Bedrock (Claude 3 Haiku):
  • Acts as the core natural language processing engine.
  • Leverages Claude 3 Haiku due to its sub-second response latency, strict instruction-following capabilities, and cost efficiency ($0.00025 per 1,000 input tokens).
  1. AWS Lambda (Python 3.12):
  • Operates as a stateless backend service retrieving requests, formatting prompt payloads, invoking Amazon Bedrock via the AWS SDK ( boto3 ), and handling response parsing.
  • Exposed directly via a Public Lambda Function URL with Cross-Origin Resource Sharing (CORS) enabled, removing the need for an additional API Gateway layer for lightweight workloads.
  1. GitHub Pages:
  • Serves static assets ( index.html , inline CSS, and client-side JavaScript) globally over HTTPS at zero hosting cost.

4. Implementation Deep-Dive

A. Serverless Backend Development ( lambda_function.py )

The AWS Lambda function processes incoming JSON payloads containing developer input ( yesterday ,  today ,  blockers ,  tone ), constructs a structured prompt payload, and calls the Bedrock Runtime API:
import json
import boto3

# Initialize Bedrock Runtime Client in us-east-1
bedrock = boto3.client(service_name='bedrock-runtime', region_name='us-east-1')

def lambda_handler(event, context):
try:
body = json.loads(event.get('body', '{}'))
yesterday = body.get('yesterday', 'Completed assigned tasks')
today = body.get('today', 'Continuing sprint backlog items')
blockers = body.get('blockers', 'None')
tone = body.get('tone', 'Professional & Clear')

prompt = f"""
You are an expert AI assistant helping a software engineer draft a daily stand-up update for Slack/Teams.
Input Context:
- Yesterday: {yesterday}
- Today: {today}
- Blockers: {blockers}
- Requested Tone: {tone}

Formatting Rules:
1. Format into 3 distinct sections: Yesterday, Today, Blockers.
2. Apply clear markdown/Slack formatting (e.g. bolding, bullet points, relevant emojis).
3. Match the requested tone ({tone}).
4. Keep the output concise and ready for immediate copy-pasting.
"""

payload = {
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 300,
"messages": [{"role": "user", "content": prompt}]
}

# Invoke Amazon Bedrock Model
response = bedrock.invoke_model(
modelId='anthropic.claude-3-haiku-20240307-v1:0',
contentType='application/json',
accept='application/json',
body=json.dumps(payload)
)

response_body = json.loads(response['body'].read())
standup_text = response_body['content'][0]['text']

return {
'statusCode': 200,
'headers': {
'Access-Control-Allow-Origin': '*',
'Access-Control-Allow-Headers': 'Content-Type',
'Access-Control-Allow-Methods': 'OPTIONS,POST',
'Content-Type': 'application/json'
},
'body': json.dumps({'standup': standup_text})
}

except Exception as e:
return {
'statusCode': 500,
'headers': { 'Access-Control-Allow-Origin': '*' },
'body': json.dumps({'error': str(e)})
}

B. Security & IAM Access Management

To enforce the principle of least privilege, an inline IAM policy was granted to the Lambda execution role specifically allowing  bedrock:InvokeModel  access:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "bedrock:InvokeModel",
"Resource": "arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-3-haiku-20240307-v1:0"
}
]
}

5. Sample Input vs. AI Generated Output

Raw User Input:

  • Yesterday:  Fixed EKS ingress routing bug, reviewed 2 pull requests, updated terraform scripts 
  • Today:  Configuring KEDA autoscaling rules and setting up Grafana dashboard 
  • Blockers:  Waiting for IAM role approval from DevOps team 
  • Selected Tone:  Professional & Clear 💼 

AI Agent Output:

🟢 *Yesterday:*
• Resolved EKS ingress routing configuration issues
• Conducted code reviews for 2 open pull requests
• Updated Terraform infrastructure scripts

🔵 *Today:*
• Configuring KEDA auto-scaling metrics and trigger rules
• Setting up Grafana monitoring dashboards for cluster observability

🔴 *Blockers:*
• Awaiting IAM role policy approval from the DevOps team

6. Key Learnings & Takeaways

  1. Simplicity of Lambda Function URLs: For single-purpose micro-apps, AWS Lambda Function URLs provide a streamlined alternative to API Gateway, significantly reducing setup complexity while supplying native CORS handling.
  1. Low-Latency Generative Workloads: Amazon Bedrock's integration via  boto3  delivers model responses in under 800ms, ensuring a responsive user experience on the web frontend.
  1. Zero Maintenance Cost: Operating within the AWS Free Tier (1 Million free Lambda requests/month + Bedrock pay-per-token pricing) keeps operational overhead effectively at $0.00 for personal and small-team usage.

7. Project Resources & Live Demo

Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article