DEV Community: Gedion Daniel

How to Become an AWS Community Builder: Complete Guide for 2026 Applications

Gedion Daniel — Sat, 27 Dec 2025 15:13:05 +0000

The AWS Community Builders program is a transformative opportunity for passionate cloud enthusiasts to elevate their AWS journey, connect with like-minded builders worldwide, and make a meaningful impact on the global AWS community. If you're considering applying for the 2026 cohort, this comprehensive guide will walk you through everything you need to know to stand out in your application.

What is the AWS Community Builders Program?

The AWS Community Builders program is a global initiative designed to support and recognize technical enthusiasts and emerging thought leaders who actively share AWS knowledge and engage with the cloud community. It's not a certification program, nor is it a job it's a vibrant community of builders dedicated to learning, sharing, and growing together.

The program accepts builders from diverse backgrounds and regions, focusing on those who demonstrate consistent community engagement through content creation, knowledge sharing, and helping others learn AWS.

Program Categories for 2026

When applying, you'll select a specialty category that aligns with your expertise and interests. The current categories include:

Serverless
Containers
Machine Learning & AI
Security & Identity
Data (Databases, Analytics)
Developer Tools
Front-End Web and Mobile
Cloud Operations
Networking & Content Delivery
Storage

Choose the category where you've actively contributed and have genuine interest. Don't try to fit into a category just because it seems popular authenticity matters more than anything else.

Key Benefits of Joining

The AWS Community Builders program offers incredible benefits that extend far beyond swag:

Technical Resources:

$500-$1000 in AWS credits for hands-on experimentation
100% voucher coverage for AWS certification exams (Foundational, Associate, or Professional/Specialty)
Early access to new AWS services and features
Direct access to AWS service teams and subject matter experts

Learning & Development:

Exclusive technical webinars and workshops
Mentorship from AWS subject matter experts
Best practices for content creation and community engagement
Support for submitting CFPs and securing speaking engagements

Community & Networking:

Global network of fellow builders
Exclusive Slack workspace for collaboration
Opportunities to volunteer at AWS events
Discount passes for AWS Summits and re:Invent

Recognition:

Listing in the official AWS Community Builders Directory
Exclusive AWS-branded merchandise and swag kits
Opportunity to influence AWS product development
Potential pathway to the AWS Heroes program

My Journey: A Personal Experience

Let me share my experience as someone who successfully joined the AWS Community Builders program in the Serverless category.

When I applied, I had been consistently writing blog posts about AWS services and sharing what I was learning with the community. This wasn't about being an expert it was about documenting my learning journey and making AWS concepts accessible to others. That consistency and commitment to helping others learn became my strongest signal.

What Helped Me Stand Out

1. Consistent Content Creation
I wrote blog posts regularly about AWS services, serverless architectures, and solutions to common challenges. I didn't wait until I was an "expert" I shared my learning journey authentically, including the mistakes and lessons learned along the way.

2. Three Critical Public Links
The application requires three public links that showcase your contributions. This is arguably the most important part of your application. I attached:

Technical blog posts I had written
AWS certifications I had earned
Documentation of community events and workshops
Any AWS-related course completion certificate links or in-progress course links that show I am learning.

How to Apply: Step-by-Step Guide

Important Dates

Application Window: Opens in January 2026
Deadline: Typically mid-January (approximately January 20, 2026)
You can join the waitlist at the AWS Community Builders page to be notified when applications open

Prerequisites

Age Requirement: Must be 18 years or older

Community Contributions: You need at least two genuine, recent contributions to the AWS community. These should be from within the last year, demonstrating current momentum rather than past achievements.

Public Links: All evidence must be publicly accessible. AWS can't consider private repositories, internal documents, or content behind paywalls.

The Application Process

Step 1: Create Your AWS Builder ID
Before starting your application, create a free Builder ID. Use the name you're known by in your content, not necessarily your legal name. For example, if you publish as "CloudGuru Alex," use that name throughout keep it consistent across your Builder ID, application, and content.

Step 2: Choose Your Category
Select the category where you've already made contributions. If you want to apply for AI, for example, you should already have blog posts, videos, talks, or projects related to AWS AI/ML services. Don't choose a category you plan to explore choose one where you've already been active.

Step 3: Prepare Your Three Public Links
This is crucial. Your three links should demonstrate:

Technical depth and accuracy
Ability to explain complex concepts clearly
Genuine value to the community
Consistency in contribution

Examples of strong links:

In-depth technical blog posts or tutorials
Video content or presentations from meetups/conferences
Open-source projects or contributions
AWS certifications (though this alone isn't sufficient)
Community or event documentation (photos, recordings, testimonials)

For community organizers: Include Zoom meeting screenshots, event photos, video recordings of talks, workshop materials, or testimonials from participants.

Step 4: Write Your Story (1000 characters or less)
Share your cloud journey authentically. AWS wants to understand:

Why you're passionate about AWS and cloud computing
How you're already helping others in the community
Your vision for continued contribution
What makes your perspective unique

Step 5: Highlight Community Impact
Emphasize how you're helping others learn AWS. If you're an AWS Captain or community organizer, showcase this prominently. AWS is looking for people who:

Organize or participate in user group meetings
Run workshops or training sessions
Answer questions in forums (re:Post, Stack Overflow, Reddit)
Create educational content consistently
Mentor other builders

Step 6: Complete All Legal Questions
Don't skip any questions, especially about communication preferences. If you don't opt in to emails, AWS can't notify you about your application status, even if you're accepted.

What Makes a Successful Application?

Based on program insights and successful applicants' experiences, here's what AWS explicitly looks for:

Recent and Consistent Contributions

The AWS team evaluates your current behavior and momentum, not what you did years ago. They want to see contributions from within the last year. Many applications fail because candidates start contributing too late or only after discovering the program.

Quality Over Quantity

One well-written, in-depth blog post that helps others solve a real problem is worth more than ten superficial posts. Focus on:

Technical accuracy
Clear explanations
Practical value
Unique insights or approaches

Community Engagement

It's not just about creating content it's about engaging with the community:

Responding to comments on your posts
Participating in forums and discussions
Attending or organizing meetups
Helping others solve problems
Collaborating on open-source projects

Authentic Passion

AWS values genuine enthusiasm over polished expertise. Show that you're passionate about:

Learning AWS services
Sharing knowledge with others
Growing the AWS community
Continuous learning and improvement

Specific Tips for Different Categories

For AI Category Applicants

Share blog posts about using Amazon Bedrock, SageMaker, or Rekognition
Create tutorials on building AI applications with AWS services
Discuss AI/ML best practices and architectural patterns
Demonstrate practical projects using AWS AI services
Participate in AI-focused AWS events or hackathons

For Serverless Category Applicants

Write about Lambda functions, API Gateway, Step Functions
Share serverless architecture patterns and best practices
Create tutorials on event-driven architectures
Discuss cost optimization in serverless applications
Contribute to serverless frameworks or tools

For Any Category

Pick the category that genuinely reflects your contributions, not what seems easiest or most popular
Ensure your three public links align with your chosen category
Demonstrate both breadth and depth in your selected specialty

Common Mistakes to Avoid

1. Starting Too Late
Don't discover the contribution requirement while filling out the application. Start contributing at least 3-6 months before applications open.

2. Focusing Only on Certifications
While certifications are valuable, a post saying "I passed my certification exam" doesn't help other builders learn AWS. Focus on teaching concepts, sharing solutions, and creating educational content.

3. Using Company Content
Only share content you personally created and own. Company blog posts or internal documentation won't count unless they're under your name and publicly accessible.

4. Inconsistent Naming
Use the same name across your Builder ID, application, and content. Inconsistency can make it harder for AWS to verify your contributions.

5. Generic or Brief Content
Avoid surface-level content. Dive deep, share real-world experiences, include code examples, and provide actionable insights.

6. Ignoring Community Engagement
Creating content in isolation isn't enough. Show that you engage with others, respond to questions, and participate in the community ecosystem.

Building Your Portfolio Before You Apply

If you're planning to apply in January 2026, start preparing now:

3-6 Months Before Application:

Start writing blog posts regularly (aim for at least 2-4 quality posts)
Create video tutorials or presentations
Participate actively in AWS forums and communities
Attend local AWS user group meetings
Consider organizing a workshop or study group
Earn an AWS certification if you haven't already

1-2 Months Before Application:

Review and polish your best content
Gather evidence of community impact (screenshots, testimonials, metrics)
Prepare your three strongest public links
Draft your cloud story
Get feedback from other Community Builders if possible

What to Include in Your Three Public Links

For maximum impact, your links should showcase:

Link 1: Technical Depth
A comprehensive blog post or tutorial that demonstrates your deep understanding of AWS services. Include code examples, architecture diagrams, and practical insights.

Link 2: Community Impact
Evidence of helping others this could be:

A popular post that solved a common problem
Video of a presentation or workshop you led
Documentation of events you organized
Open-source contribution that benefits the community

Link 3: Consistency or Specialization
Show either consistent contributions (multiple blog posts in your category) or specialized expertise (a particularly impressive project or achievement).

For Community Organizers:

Event photos with participant counts
Zoom recordings of virtual meetups
Testimonials from participants
Documentation of workshops or training sessions
Links to user group pages or event announcements

After Submitting Your Application

Be Patient
AWS receives thousands of applications globally. The review process takes time, often several weeks or months. Applications are typically reviewed once a year.

Continue Contributing
Don't stop creating content while waiting. Continue your normal contribution patterns. Many successful applicants kept building their portfolios throughout the review period.

Don't Get Discouraged by Rejection
Many successful Community Builders weren't accepted on their first attempt. If you're not selected:

Ask for feedback if possible
Continue contributing to the community
Strengthen your portfolio
Apply again next year with improved evidence of impact

The application process is competitive, with acceptance rates around 12-15% growth year over year. Rejection doesn't reflect your technical skills it often means you need more visible community contributions.

Once You're Accepted

As a Community Builder, you're encouraged to:

Participate in virtual calls and community sessions
Continue creating educational content
Engage actively in the Slack workspace
Attend or volunteer at AWS events
Try new services with your AWS credits
Use certification vouchers to advance your skills
Share feedback with AWS service teams
Mentor other aspiring builders

The program runs in one-year intervals, and you'll need to reapply annually if you want to continue. Reapplication focuses on showing examples of your contributions during your time as a Community Builder.

Success Stories and Impact

Being an AWS Community Builder can significantly impact your career and technical growth:

Many Community Builders have become AWS Heroes
Builders gain recognition in the global AWS community
The network opens doors to speaking opportunities at major conferences
Direct access to AWS teams accelerates learning and innovation
The community provides mentorship and collaboration opportunities
Some builders have launched consulting careers or joined AWS itself

Final Thoughts

The AWS Community Builders program is more than a title or a collection of benefits it's about becoming part of a global movement of builders who are passionate about AWS and committed to helping others succeed.

You don't need to be an expert to apply. You need to be:

Passionate about AWS and cloud computing
Committed to sharing knowledge
Actively helping others in the community
Consistent in your contributions
Authentic in your approach

If you're organizing events, writing blog posts, creating videos, answering questions in forums, or contributing to open-source projects, you're already on the right path. Document your contributions, gather your evidence, and prepare to share your story.

The January 2026 application window will open soon. Start preparing now build your portfolio, engage with the community, and get ready to submit a strong application. Even if you're not accepted on your first attempt, the process of preparing and contributing will accelerate your growth and strengthen your position for future applications.

Remember, the AWS Community Builders program is looking for people who are already builders at heart people who naturally share, teach, collaborate, and contribute. If that describes you, don't hesitate to apply. The community needs your unique perspective and contributions.

Resources and Next Steps

Join the Waitlist: AWS Community Builders Program
Follow Jason Dunn (AWS Community Builders Program Manager) on LinkedIn for the latest updates
Browse Current Community Builders: Check out the Community Builders Directory for inspiration
Join AWS User Groups: Find a local or virtual AWS user group in your area
Create Your Builder ID: Set up your free AWS Builder ID today

The journey to becoming an AWS Community Builder starts with a single contribution. Start creating, start sharing, and start building your community is waiting.

Good luck with your application, and I hope to see you in the AWS Community Builders program soon!

👨‍💻 Connect with me:
📌 LinkedIn
📂 GitHub

My Journey to AWS Certified AI Practitioner

Gedion Daniel — Thu, 14 Aug 2025 11:07:27 +0000

🏅 View my badge here: https://lnkd.in/d-TnX4qd

This certification is designed for anyone looking to validate their understanding of AI, Machine Learning (ML), and Generative AI, especially in the context of AWS cloud services.

My Learning Timeline

My journey took a few months of focused study. Initially, I wasn’t sure which resources to prioritize, and I didn’t start with hands-on exercises right away. Once I structured my learning around practical labs, official AWS content, and practice exams, my progress accelerated significantly.

Learning Resources

Here’s what helped me the most:

1. Stéphane Maarek’s AWS AI Practitioner Course

Course Link Stéphane’s course is thorough and beginner-friendly. His clear explanations and practical examples made AI/ML concepts easy to understand.

2. AWS Skill Builder – Exam Prep

Skill Builder Link The official AWS learning platform offered structured modules aligned with exam objectives. Interactive exercises and up-to-date content complemented the course perfectly.

3. Practice Exams by Stéphane Maarek

Practice Exams Link The practice exams were slightly more challenging than the real test, which built confidence and helped me identify weak areas.

What the Exam Covers

The AI Practitioner exam tests your understanding of:

Core AI/ML concepts and Generative AI fundamentals
AWS AI/ML services like Amazon SageMaker, Bedrock, Rekognition, Comprehend, and more
Responsible AI and ethical considerations
The ML lifecycle: data preparation, model training, evaluation, deployment
Types of learning: supervised, unsupervised, reinforcement
Evaluation metrics: accuracy, precision, recall, F1, etc.

Exam Experience

I opted to take the exam online, but I recommend preparing your environment carefully to avoid distractions or connectivity issues. The exam itself is beginner-friendly with moderate difficulty — a perfect entry point into AI/ML on AWS.

Conclusion

Earning the AWS Certified AI Practitioner certification is a significant milestone in my AI/ML journey. Combining Stéphane Maarek’s course, AWS Skill Builder, and rigorous practice exams made the preparation structured and achievable.

For anyone preparing, my advice:

Use both official AWS materials and trusted third-party courses
Do plenty of hands-on labs
Practice with mock exams to boost confidence

This exam is not just about passing — it’s about building a solid foundation for your career in AI, ML, and cloud computing.

Let’s keep learning and growing! 🚀

👨‍💻 Connect with me:
📌 LinkedIn
📂 GitHub
🖥️ Website

Creating an Amazon Bedrock Nova Canvas MCP Server and Claude Desktop Integration

Gedion Daniel — Mon, 11 Aug 2025 17:17:40 +0000

let's create an MCP Server using AWS Resources. This example shows how to call the Amazon Nova Canvas model in natural language through Claude Desktop to generate images.

First, set up a Python project locally by running the following commands:

uv init mcp-nova-canvas
cd mcp-nova-canvas

uv venv
source .venv/bin/activate

uv add "mcp[cli]"

Set up the necessary dependencies in pyproject.toml:

[project]
name = "mcp-nova-canvas"
version = "0.1.0"
description = "Add your description here"
readme = "README.md"
requires-python = ">=3.11"
dependencies = [
    "boto3>=1.37.24",
    "httpx>=0.28.1",
    "mcp[cli]>=1.8.0",
    "pillow>=11.1.0",
    "uuid>=1.30",
    "loguru"
]

Paste main.py into the main.py, create and paste utils.py into the utils.py, constants.py into the constants.py file.

Add the following content to the claude_desktop_config.json file to check in Claude Desktop:

{
    "mcpServers": {
        "canvas": {
            "command": "uv",
            "args": [
                "--directory",
                "/ABSOLUTE/ATH/TO/PARENT/FOLDER/mcp-nova-canvas",
                "run",
                "main.py"
            ]
        }
    }
}

💡 Tip: If you have trouble finding the file, run Claude Desktop and look in Settings -> Developer -> Edit Config.

Click File -> Exit and Restart Claude Desktop and enter "generate_image YOUR PROMPT":
Check the image in the output folder in the main directory.

Summary
In this module, you learned how to build an MCP server in a local environment and integrate it with Claude Desktop.

👨‍💻 Connect with me:
📌 LinkedIn
📂 GitHub
🖥️ Website

Sticky Sessions: How One Simple Fix Solved Our User Experience Nightmare

Gedion Daniel — Mon, 11 Aug 2025 14:55:45 +0000

Have you ever wondered how websites remember your shopping cart even when multiple servers are handling your requests? That's where sticky sessions come in! Let's break down what they are and why they matter, including how they helped solve a real problem at our company.

What Are Sticky Sessions?

Imagine you're at a busy restaurant with multiple servers. Sticky sessions are like having the same waiter serve you throughout your entire meal, instead of getting a different waiter each time you need something. In the tech world, this means directing a user to the same server for all their requests during their visit.

Why Are They Important?

Session Data Management: When you log into a website, your session information (like your login status or shopping cart) is often stored on the server. If you keep getting sent to different servers, this information might get lost.

Better Performance: Your first server already has your information loaded, so staying with it can make things faster.

Consistency: It prevents weird issues that can happen when different servers handle your requests.

Our Real-World Problem and Solution

We recently faced a challenging situation at our company. Users were experiencing issues because each time they made an API call, they would get connected to a different server. This caused problems because:

Session information wasn't consistent
Users had to log in multiple times
Data sometimes appeared to be missing

The solution? We enabled sticky sessions! This simple change made sure that once a user connected to a server, they stayed with that same server for their entire session. The results were immediate:

Users stayed logged in
Data remained consistent
The overall experience became much smoother

How Sticky Sessions Work

First Visit: When you first visit a website, the load balancer assigns you to a server
Cookie Creation: A special cookie is created that helps remember which server you're using
Future Requests: The load balancer reads this cookie and sends you back to the same server

When Should You Use Sticky Sessions?

Sticky sessions are great when:

Your application stores session data on individual servers
You need to maintain user state during a session
You're dealing with stateful applications
You want to ensure consistent user experience

Best Practices

Set Appropriate Timeouts: Don't make sessions stick forever

Plan for Server Failures: Have a backup plan in case a server goes down

Monitor Session Distribution: Make sure users are spread evenly across servers

Consider Alternatives: For some cases, distributed caching might be better

Conclusion

Sticky sessions might seem like a small detail, but they can make a huge difference in how well your application works. Our company's experience shows how a simple configuration change can solve significant problems. Whether you're running a small website or a large application, understanding and properly implementing sticky sessions can help provide a better, more reliable experience for your users.

Remember: In the world of web applications, sometimes being "sticky" is exactly what you need!

👨‍💻 Connect with me:
📌 LinkedIn
📂 GitHub
🖥️ Website

Amazon S3 – Pre-Signed URLs: My Experience Making File Sharing Easier

Gedion Daniel — Sun, 10 Aug 2025 19:30:19 +0000

When I first started working with Amazon S3, I knew it was a great way to store and manage files in the cloud. But I quickly ran into a challenge: how could I share a file with someone securely without opening up my entire bucket? After some searching, I found out about Pre-Signed URLs, and they've made my life so much easier.

Here's a bit about what they are, how they work, and how I've used them in my projects. Hopefully, this will help you get started with them too!

What Are Pre-Signed URLs?
A Pre-Signed URL is a unique, temporary link that gives access to a specific file (or "object") in an S3 bucket. When you create a Pre-Signed URL, you're essentially giving permission to access that file, but only for a set time. This has been incredibly useful in my projects, where I often need to share files or let users upload documents without permanently making everything public.

In simple terms, think of it like a temporary key that opens the door to a specific file, but the key automatically disappears after a set period.

How I First Used Pre-Signed URLs
My first experience with Pre-Signed URLs was in a project where users needed to download PDFs. I wanted to ensure these files weren't accessible forever or by just anyone. This is where Pre-Signed URLs saved me a lot of hassle.

Instead of setting up complicated access controls for every user, I could create a link that worked for only a few hours. This was perfect for securely sharing files without over-complicating permissions.

How Pre-Signed URLs Work in Practice
Setting up a Pre-Signed URL is simple once you get the hang of it. Here's the process I followed:

Generate the URL: I specified which file in my S3 bucket I wanted to share. For me, it was often reports or images.

Set the Expiration: I usually set my URLs to expire after 24 hours, but you can choose any time limit.

Use the URL in My Application: I could pass the link directly to users, who could click it to access the file. After the time was up, the link no longer worked.

The best part? I could generate these links programmatically with code, which made it easy to integrate them directly into my app. Here's a basic example in Python, using the boto3 library:

import boto3

s3_client = boto3.client('s3')

bucket_name = 'my-bucket'
object_name = 'my-file.pdf'
expiration = 86400  # 24 hours

url = s3_client.generate_presigned_url('get_object',
                                        Params={'Bucket': bucket_name,
                                                'Key': object_name},
                                        ExpiresIn=expiration)

print("Pre-Signed URL:", url)

With this code, I could print out a secure link to a file in my S3 bucket that would last only 24 hours. The person receiving the link could download the file within that time, and I didn't have to worry about ongoing access.

Real-Life Use Cases I've Worked On
Secure Document Sharing: I worked on a project where users needed to download confidential reports. Using Pre-Signed URLs, I could control access so each report was available only for a limited time. This worked perfectly, as it allowed users to download the report when they needed it without risking it being permanently accessible.

Photo Uploads in an App: In another project, users uploaded photos directly to an S3 bucket. Instead of giving public access, I generated Pre-Signed URLs for each upload. Users could upload files through the URL without needing AWS credentials, keeping things secure.

Automatic Expiry for Sensitive Files: In a recent project, I had files that were only relevant for a few hours, like temporary contracts. With Pre-Signed URLs, I could automatically expire access, which meant I didn't have to worry about deleting files or updating permissions manually.

Why I Recommend Pre-Signed URLs
If you're working with files in S3, Pre-Signed URLs are incredibly useful. They offer several benefits:

Security without Complexity: You don't have to set up complex user permissions; just generate a URL with a time limit, and the file access is controlled.

Flexibility: You can set different expiration times based on the use case—anything from a few minutes to several days.

Access Control: Since the URL expires, you don't have to worry about old links sticking around and causing security issues.

One thing I found helpful is testing the URLs with different expiration times to see what works best for the project. For longer-lasting files, I might set a 24-hour limit, but for others, 1–2 hours might be enough.

Tips from My Experience
Set Clear Expiry Times: Start with shorter expiration times until you find the best fit for your users. Too long, and you might have lingering links; too short, and users might find the links expire before they even get to use them.

Automate Link Generation: If your project allows, automate the Pre-Signed URL generation so that links are created and shared instantly without extra effort.

Experiment with Permissions: You can set URLs to allow upload or download. I found it helpful to test different permissions in my projects to avoid unexpected access issues.

Final Thoughts
Working with Pre-Signed URLs in Amazon S3 has been a game-changer for me. They're simple to create, flexible, and secure, and they've solved the challenge of controlled file sharing in my applications. Whether you need to share files temporarily or allow uploads securely, Pre-Signed URLs are a powerful tool to have in your AWS toolkit.

👨‍💻 Connect with me:
📌 LinkedIn
📂 GitHub
🖥️ Website

AWS SES with a NestJS Backend to Send Email Verifications

Gedion Daniel — Sat, 09 Aug 2025 05:56:33 +0000

In my latest project, I needed to set up email verification to make sure users are providing valid email addresses when signing up. To do this, I integrated AWS SES (Simple Email Service) with my NestJS backend to send verification emails with a code that users could use to confirm their email addresses.

If you're working on something similar or just want to know how it works, let me walk you through the process. I'll keep it simple and personal to make it easy to understand.

What is AWS SES?

AWS SES (Simple Email Service) is a cloud-based email service by AWS that lets you send emails easily and at scale. You can use it to send transactional emails, marketing emails, or, in my case, verification emails.

Why Use AWS SES for Email Verification?

There are a few reasons I chose AWS SES for this project:

Reliable and high deliverability - Fewer emails end up in the spam folder
Scalable - Works even if your app grows and needs to send more emails
Cost-effective - Pay only for what you use

Setting Up AWS SES

The first step is setting up AWS SES in your AWS account. Here's what I did:

1. Create an AWS Account

If you don't have one yet, sign up at AWS.

2. Verify Your Domain or Email

In the SES console, I verified the domain that my app's emails would come from. Alternatively, you can verify a single email address, but verifying a domain is better for production apps.

3. Move Out of SES Sandbox

By default, AWS SES puts new accounts in a sandbox, which limits the number of emails you can send. I requested production access to remove these limits.

4. Obtain AWS Credentials

To use AWS SES in my NestJS backend, I needed my Access Key and Secret Key.

Installing AWS SDK in NestJS

Once AWS SES was ready, the next step was integrating it into my NestJS backend. First, I installed the AWS SDK for JavaScript:

npm install @aws-sdk/client-ses

This package allows my NestJS application to interact with AWS SES to send emails.

Writing the NestJS Service to Send Emails

Next, I wrote a service in my NestJS app to handle the sending of verification emails. Here's a simple version of the code:

import { Injectable } from '@nestjs/common';
import { SESClient, SendEmailCommand } from '@aws-sdk/client-ses';

@Injectable()
export class EmailService {
  private sesClient: SESClient;

  constructor() {
    this.sesClient = new SESClient({ region: 'your-region' });
  }

  async sendVerificationEmail(email: string, code: string): Promise<void> {
    const params = {
      Source: 'your-verified-email@yourdomain.com',
      Destination: {
        ToAddresses: [email],
      },
      Message: {
        Body: {
          Text: { Data: `Your verification code is: ${code}` },
        },
        Subject: { Data: 'Email Verification' },
      },
    };

    const command = new SendEmailCommand(params);
    await this.sesClient.send(command);
  }
}

How It Works:

I initialized the SESClient with my AWS region
The sendVerificationEmail method takes the recipient's email and a verification code as inputs
The email contains a subject line ("Email Verification") and a message body with the verification code
The SendEmailCommand sends the email via AWS SES

Calling the Service from the Controller

Next, I created a controller that handles requests from the frontend. When a user registers or requests a verification email, this controller sends the email:

import { Controller, Post, Body } from '@nestjs/common';
import { EmailService } from './email.service';

@Controller('auth')
export class AuthController {
  constructor(private readonly emailService: EmailService) {}

  @Post('send-email-verification')
  async sendVerificationEmail(@Body('email') email: string) {
    const verificationCode = this.generateVerificationCode();
    await this.emailService.sendVerificationEmail(email, verificationCode);
    return { message: 'Verification email sent' };
  }

  private generateVerificationCode(): string {
    return Math.floor(100000 + Math.random() * 900000).toString(); // 6-digit code
  }
}

How It Works:

The AuthController listens for a POST request at the /auth/send-email-verification endpoint
It calls the EmailService to send the verification email to the user's email address with a 6-digit verification code
The verification code is randomly generated as a 6-digit number

Testing the Integration

After setting everything up, I tested the functionality. I used Postman to make a request to the /auth/send-email-verification endpoint with a test email. Sure enough, the email showed up in my inbox with the verification code.

Conclusion

Setting up email verification with AWS SES and NestJS is straightforward once you understand the pieces involved. The combination provides a reliable, scalable solution for email verification that can grow with your application.

Key Takeaways:

AWS SES provides reliable email delivery at scale
The AWS SDK makes integration with NestJS simple
Always verify your domain for production use
Remember to request production access to move out of the SES sandbox

Feel free to adapt this setup to your specific needs, such as using HTML templates for prettier emails or storing verification codes in a database for validation.

👨‍💻 Connect with me:
📌 LinkedIn
📂 GitHub
🖥️ Website

How the Pool Pattern Works in Multi-tenant RAG

Gedion Daniel — Fri, 08 Aug 2025 07:38:58 +0000

The pool pattern is a shared infrastructure approach where all tenants use the same Amazon Bedrock Knowledge Base, S3 bucket, and vector database. Here's how it works based on the implementation:

Core Concept

Instead of creating separate resources for each tenant, everyone shares:

One S3 bucket for all documents
One Knowledge Base for processing
One vector database (Pinecone, or AWS OpenSearch as an alternative) for storing embeddings
Metadata filtering to keep data separated

Step-by-Step Process

1. Document Upload with Tenant Metadata

When a user uploads a document, the system creates two files in S3:

// Original document
s3Key = `users/${userId}/agents/${agentId}/documents/${documentId}/${filename}`

// Metadata file (CRITICAL for tenant isolation)
metadataKey = `${document.s3Key}.metadata.json`

The metadata file contains:

{
  "metadataAttributes": {
    "userId": "user123",
    "username": "john_doe",
    "agentId": "agent456",
    "filename": "report.pdf",
    "uploadDate": "2025-01-15T10:30:00Z"
  }
}

This metadata is what enables tenant isolation in the shared system.

2. Shared Knowledge Base Processing

All documents go through the same Knowledge Base:

// Single shared Knowledge Base for all tenants
await this.bedrockClient.send(new StartIngestionJobCommand({
  knowledgeBaseId: this.configService.get('SHARED_KNOWLEDGE_BASE_ID'),
  dataSourceId: this.configService.get('SHARED_DATA_SOURCE_ID'),
}));

The Knowledge Base:

Chunks all documents the same way
Uses the same embedding model
Stores vectors with the metadata in Pinecone

3. Querying with Tenant Isolation

When a user asks a question, the system filters results by their tenant ID:

filter: {
  andAll: [
    {
      equals: {
        key: 'userId',
        value: userId,  // Only this user's documents
      },
    },
    {
      equals: {
        key: 'agentId',
        value: agentId,  // Only this specific agent's documents
      },
    },
  ],
}

This ensures User A never sees User B's documents, even though they're in the same database.

Visual Flow

User uploads document → Creates S3 object + metadata.json
Knowledge Base ingests → Processes both files together
Vectors stored in Pinecone → With userId and agentId metadata
User queries → Filter applied → Only their documents returned

Key Implementation Details

Agent Creation

Each user can have multiple agents (like different assistants):

async createAgent(userId: string, name: string, description?: string) {
  return await this.agentModel.create({
    userId: userId,
    name,
    description,
    knowledgeBaseId: this.configService.get('SHARED_KNOWLEDGE_BASE_ID'),
    dataSourceId: this.configService.get('SHARED_DATA_SOURCE_ID'),
  });
}

Multi-Model Support

Users can choose different AI models while sharing the same knowledge base:

// User can select Claude, Mistral, Titan, etc.
const selectedModelKey = modelKey || session.modelKey || 'claude3Sonnet';

User Registration

New users automatically get access to the shared infrastructure:

await this.userModel.create({
  cognitoId: response.UserSub,
  username: username,
  email: email,
  // Pool pattern benefits - instant access to shared resources
  tier: 'starter',
  maxAgents: 5,
  maxDocuments: 100,
  maxMessagesPerMonth: 1000,
});

Why This Works

Cost Efficient: One Knowledge Base serves hundreds of tenants
Simple Onboarding: New user? Just start uploading - no setup needed
Flexible: Each tenant can use different AI models
Secure: Metadata filtering ensures complete data isolation

Critical Success Factor

The .metadata.json file is crucial. Without it:

Documents won't be filterable by tenant
Data isolation breaks
The entire multi-tenant system fails

Always ensure every document has its corresponding metadata file with the correct userId and agentId.

👨‍💻 Connect with me:
🖥️ Website
📌 LinkedIn
📂 GitHub
📝 Blog

🔥Invoke Amazon Bedrock Models Using Python: Full Code Walkthrough with Mistral AI

Gedion Daniel — Sat, 07 Jun 2025 19:14:48 +0000

Amazon Bedrock is a powerful AWS service that lets you build and scale generative AI applications using foundation models from top providers such as Mistral AI, Anthropic, Meta, Cohere, Amazon Titan, and others all without managing infrastructure.

In this blog, we'll walk through how to invoke a foundation model on Amazon Bedrock using Python, with Mistral AI as our example. You’ll see the full code, key setup steps, and how to avoid common errors.

🚧 Step 1: Enable Model Access in Amazon Bedrock

Before using any models on Bedrock, you must explicitly request access for each one.

Here's how:

Go to the Amazon Bedrock Console.
From the sidebar, click "Model access".
Choose the providers you want access to (e.g., Mistral, Anthropic, Meta).
Click "Request model access" for each.

🌍 Step 2: Set Your Region

Amazon Bedrock model availability depends on the AWS region.
To access all models and the latest features, it's recommended to use the us-west-2 region (Oregon), where most models including Mistral, Meta, Claude, and others are available.

However, for this time, I’m using the eu-north-1 region (Stockholm), which currently supports a limited set of models that suit my needs.
If you're trying to use a specific model and it's not available in your current region, try switching to us-west-2, eu-north-1, or even eu-central-1 depending on availability.

Update your AWS configuration:

aws configure

Or set environment variables:

export AWS_ACCESS_KEY_ID=your-access-key-id
export AWS_SECRET_ACCESS_KEY=your-secret-access-key
export AWS_REGION=eu-north-1 # Change this to your desired region

🐍 Step 3: Install Dependencies

Make sure Python is installed (≥ 3.7), and install boto3:

pip install boto3

🔑 Step 4: Get the API Request Format for Any Model

To find the exact kwargs payload structure for invoking a model via API:

Go to the Amazon Bedrock Console.
Choose "providers" from the sidebar.
Select a model (e.g., Mistral, Claude, Titan).
Scroll down to the "API Requests" section.
You’ll see ready-to-use API request samples.

You can copy and adapt this request for any model.
For example, if you're switching from Mistral to Claude or LLaMA, just update the modelId and keep the rest of the format similar.

In my example, I removed the type=image content block I’m only using "type": "text" in my prompt.
If you want to include images, just keep the image type block and provide a valid URL or upload method.

💻 Step 5: Write Python Code to Invoke a Bedrock Model

We’ll now write a Python script that:

Connects to Bedrock via boto3
Sends a prompt to a model
Prints the response

Create a file called invoke_bedrock.py:

import boto3
import json

# Initialize the Bedrock runtime client for the correct region
bedrock_runtime = boto3.client("bedrock-runtime", region_name="eu-north-1")

# Your question to the model
prompt = "What is the capital city of Italy?"

kwargs = {
    "modelId": "eu.mistral.pixtral-large-2502-v1:0",
    "contentType": "application/json",
    "accept": "application/json",
    "body": json.dumps({
        "messages": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": prompt
                    }
                ]
            }
        ]
    })
}

# Call Bedrock
response = bedrock_runtime.invoke_model(**kwargs)

# Parse the response
response_body = response['body'].read()
output = json.loads(response_body)

# Print the assistant's reply
assistant_message = output['choices'][0]['message']['content']
print("Model response:")
print(assistant_message)

▶️ Step 6: Run the Script

In your terminal or command prompt:

python invoke_bedrock.py

Output:

Model response:
The capital city of Italy is Rome (in Italian, "Roma"). Rome is ...

⚠️ Common Errors and Fixes

Error	Solution
`NoCredentialsError`	Run `aws configure` or set environment variables.
`ValidationException` or "inference profile required"	Use the correct model ID for your region. For general use, prefer `us-west-2`.
`modelId not found`	Use a model ID valid for your region (e.g., `mistral.mixtral-8x7b-instruct-v0:1` in `us-west-2`).

✅ Summary

You’ve now successfully:

✅ Set up AWS credentials
✅ Requested model access
✅ Written a Python script to invoke Mistral via Bedrock
✅ Printed a model response

This foundation lets you build anything from chatbots to smart assistants powered by Amazon Bedrock.

👨‍💻 Connect with me:
🖥️ Website
📌 LinkedIn
📂 GitHub
📝 Blog

🚀 How to Install and Use Amazon Q for Developers in Your IDE

Gedion Daniel — Sat, 03 May 2025 00:06:29 +0000

Amazon Q is Amazon Web Services’ AI-powered assistant designed to help developers code smarter and faster—directly inside their favorite IDEs. Whether you're writing Java in Eclipse, crafting Python in PyCharm, or debugging in Visual Studio Code, Amazon Q offers context-aware suggestions, natural language queries, and seamless integration with AWS services.

If you're ready to give Amazon Q a spin, this guide will walk you through setting it up in your IDE and getting started in just a few minutes.

💡 What is Amazon Q Developer?
Amazon Q Developer is like having an AI coding buddy built right into your workspace. It can:

Answer programming questions in natural language.

Generate code snippets based on your prompts.

Help you navigate and understand unfamiliar code.

Integrate with your AWS resources to help manage cloud applications.

And the best part? You can use Amazon Q for free without an AWS account—just authenticate with a free AWS Builder ID.

🛠️ Step 1: Check Supported IDEs
Amazon Q currently supports these IDEs:

IDE

Eclipse
JetBrains (IntelliJ, PyCharm, etc.)
Visual Studio Code
Visual Studio (Windows only)

Make sure your IDE is up to date before proceeding.

📥 Step 2: Download the Amazon Q Plugin
Choose the version that matches your development environment:

Amazon Q for Eclipse (Preview)

Amazon Q for Visual Studio Code

Amazon Q for JetBrains IDEs

Amazon Q via AWS Toolkit for Visual Studio

Install the plugin just as you would with any other IDE extension.

🔐 Step 3: Authenticate with AWS Builder ID (or IAM Identity Center)
After installing the plugin, you’ll need to sign in. You have two options:

Builder ID – Free and easy. No AWS account needed.

IAM Identity Center – For enterprise users or those with Amazon Q Developer Pro subscriptions.

🧑‍💻 Using Builder ID (Recommended for Individual Devs)
Launch your IDE and find the Amazon Q icon (usually on the toolbar or sidebar).

Click the icon and select “Use for free”.

A browser window will open, guiding you through Builder ID authentication.

Once authenticated, go back to your IDE—you're all set!

🧪 IDE-Specific Instructions
✅ Eclipse (Preview)
Click the Amazon Q icon (top right).

Authenticate using Builder ID via browser.

Return to Eclipse and start chatting with Amazon Q from the panel at the bottom.

✅ JetBrains IDEs (IntelliJ, PyCharm, etc.)
Open the side toolbar and click the Amazon Q icon.

Authenticate in the browser.

Open the chat panel or navigate via the bottom bar to interact with Q.

✅ Visual Studio Code
Click the Amazon Q icon in the sidebar.

Authenticate in your browser.

Use the side panel to begin chatting with Amazon Q.

✅ Visual Studio (Windows)
Go to Extensions > AWS Toolkit > Getting Started.

In the Amazon Q section, choose Enable.

After successful auth, return to Visual Studio to use Q.

⚠️ A Note on IAM Roles
If you typically use IAM roles or IAM credentials to access AWS services, note that Amazon Q in IDEs does not support IAM-based sign-in. You'll need to use either IAM Identity Center or Builder ID credentials.

⏳ Session Duration Info
Sessions authenticated with IAM Identity Center typically last 8 hours. However, Amazon Q extends this duration up to 90 days (for users set up on or after April 18, 2024). That means fewer interruptions for re-authentication while you’re in the zone!

🚀 Final Thoughts
Amazon Q Developer is a powerful tool for improving productivity and deepening your understanding of your own code. Setup is quick, the free tier is generous, and it integrates smoothly with your workflow.

👨‍💻 Connect with me:
🖥️ Website
📌 LinkedIn
📂 GitHub
📝 Blog