DEV Community: Mohammed N Zubair

🎮 What If AWS Bedrock Worked Like the MarioGame?

Mohammed N Zubair — Fri, 24 Jul 2026 13:17:49 +0000

🎮 When I first started learning cloud technologies, I realized something interesting.
The hardest part isn't understanding the technology itself—it's understanding
how all the pieces connect
together.

This becomes even more challenging with Generative AI.
Terms like
Foundation Models, Amazon Bedrock, Claude,Llama,Titan, and Mistral often makebeginners feel overwhelmed.

So I asked myself:
What if I explained AWS Bedrock using a game that almost everyone knows?
The answer was obvious...
Super Mario Bros.
Let's jump into the Mushroom Kingdom and see how AWS Bedrock works.

🍄 Welcome to the Mushroom Kingdom
Imagine you're playing Mario.
Princess Peach needs help.
Bowser is creating problems.
Mario's mission is to save the kingdom.
Now replace the Mushroom Kingdom with
your AI application
Maybe you've built:

A chatbot
A document summarizer
A code assistant
A customer support application Just like Mario has missions, your application has requests coming from users.

👨 Mario = Your Application
Think of Mario as your application.
Mario receives a mission, but he doesn't magically know everything.
Similarly, your chatbot doesn't automatically know how to answer every question.
Whenever your application receives a request, it needs help from an AI model.
The question is...
How does it reach that AI model?

🚪 The Warp Pipe = Amazon Bedrock
This is where the famous green Warp Pipe comes into the picture.
Mario doesn't build a separate road to every location.
He simply enters a Warp Pipe.
The pipe takes him where he needs to go.
Amazon Bedrock works exactly the same way.
Instead of connecting separately to different AI providers, your application connects to one service —Amazon Bedrock.

User
│
▼
Your Application (Mario)
│
▼
Amazon Bedrock (Warp Pipe)

The Warp Pipe becomes the gateway.
Your application doesn't need to worry about where the model lives or who built it.
Bedrock handles that complexity.

🎭 Every Character Has a Different Strength
One of the reasons Mario games are so enjoyable is that every character has unique abilities.
The same idea applies to Foundation Models.

Would you send Yoshi to every mission?
Probably not.
Sometimes Mario is the better choice.
Sometimes Luigi.
Likewise, no single AI model is perfect for every task.
One model may excel at creative writing.
Another may perform better in coding.
Another may be faster and cheaper.
Amazon Bedrock lets you choose the right model without changing your entire application.

⭐ Prompts Are Mario's Power-Ups
Mario becomes stronger depending on the power-up he collects.

A Mushroom makes him bigger.
A Fire Flower lets him throw fireballs.
A Star makes him temporarily invincible.
AI models behave in a similar way.
The quality of their response depends heavily on the prompt you provide.
A vague prompt usually produces an average answer.
A clear, detailed prompt often produces an excellent answer.
Think of prompts as the power-ups that unlock the model's true potential.

🎒 Prompt Templates = Mario's Item Box
Imagine Mario storing useful items for future levels.
Whenever he needs one, he simply picks it from his inventory.
Prompt Templates in Amazon Bedrock work in a similar manner.
Instead of writing the same prompt repeatedly, you create reusable templates.
For example:

Summarize a PDF
Translate text
Generate SQL queries
Create interview questions
Write marketing emails Your application simply selects the appropriate template whenever needed.

👸 Princess Peach = Your Users
Every application exists because someone needs help.
In Mario, that's Princess Peach.
In your application, that's your customer.
The user asks a question.
Your application receives it.
Amazon Bedrock forwards it to the appropriate AI model.
The model generates an answer.
Everyone is happy.
Hopefully... without Bowser interrupting!

🐢 Bowser Represents Complex Problems
Some tasks are simple.
Others are far more challenging.
For example:

Reading a 500-page document
Summarizing legal agreements
Analyzing financial reports
Generating production-ready code

These are the "Bowser-level" challenges.
Your application alone cannot solve them.
That's where powerful Foundation Models become the real heroes.

📚 What If Mario Doesn't Know the Answer?
Let's make the story a little more interesting.
Suppose Princess Peach asks:
"Can you tell me where the hidden key is inside the castle?"
Mario has never seen that castle before.
Guessing would be risky.

Instead, he opens the castle map.
Only then does he answer confidently.
This is exactly how Retrieval-Augmented Generation (RAG)
works.
Instead of relying only on what the AI learned during training, your application first searches your ownknowledge base.
That knowledge could come from:

PDFs
Company documents
Databases
Wikis
Internal manuals The relevant information is retrieved first. Only then is it sent to the Foundation Model. The result is an answer based on your organization's data—not just the model's general knowledge.

🌉 Why Not Connect Directly to Every AI Model?
Without Amazon Bedrock, your application might need separate integrations for each model provider.
That means:

Different APIs
Different authentication methods
Different SDKs
Different request formats

Maintaining all of these quickly becomes complicated.
Amazon Bedrock simplifies everything.
Your application integrates once.
Behind the scenes, Bedrock provides access to multiple Foundation Models through a consistent interface.

Today you might use Claude.

Tomorrow you might switch to Llama or Amazon Titan.

Your application changes very little, making experimentation and model selection much easier.

🎯 Final Thoughts

One of the best ways to learn cloud technologies is to connect them with something familiar.
For me, Mario isn't just a nostalgic game—it also offers a simple mental model for understanding Amazon
Bedrock.

Here's the complete analogy in one view:
👨 Mario → Your AI Application
🚪 Warp Pipe → Amazon Bedrock
🎭 Different Characters → Different Foundation Models
⭐ Power-Ups → Prompts
🎒 Item Box → Prompt Templates
👸 Princess Peach → Users
🐢 Bowser → Complex AI Problems
🗺️ Castle Map → RAG and Your Knowledge Base
Once you visualize it this way, AWS Bedrock becomes much less intimidating.

Instead of thinking about dozens of APIs and models, simply remember Mario.

Your application enters one Warp Pipe, Amazon Bedrock, and reaches the AI model best suited for the
mission.
And that's exactly what Amazon Bedrock was designed to do.

💬 Over to You
Have you ever used games or real-life analogies to explain cloud or AI concepts?
I'd love to hear your favorite analogy in the comments.

Happy Learning! 🚀

AI is Like a New Employee

Mohammed N Zubair — Thu, 16 Jul 2026 09:59:07 +0000

Understanding LLMs, RAG, Embeddings, and Vector Databases

Based on the 'Tea Shop Example' Analogy

Core Concepts Overview
• LLM (Smart Employee): The brain. It knows how to communicate but doesn't know your specific business secrets yet.
• RAG (Finds the Right Info): The process of looking up the right page in the manual instead of reading the whole book every time.
• Embeddings (Meaning into Numbers): Converting words into mathematical coordinates so the AI understands 'context' and 'similarity'.
• Vector DB (Quick & Smart Search): The filing cabinet or 'Google Maps' that stores these coordinates for lightning-fast retrieval.

Introduction: The Tea Shop Analogy
Imagine you hire a new employee for your tea shop. On the first day, a customer asks, 'Do you have Ginger Tea?' The employee says, 'I don't know.' This isn't because they are a bad employee; they simply haven't learned your specific menu yet. Generative AI works exactly the same way. Without knowledge, it guesses (hallucinates). With knowledge, it answers confidently.

Step 1: The New Employee (LLM)
An LLM (Large Language Model) is like a smart new employee. It already comes equipped with general knowledge—it understands English, grammar, and basic communication.
The Problem:
It doesn't know your specific business. If you ask a foundational model, 'What is the leave policy of my company?', it cannot answer because it was never trained on your private company documents.
Trainer Context/Deep Dive:
This is a great place to explain that training an LLM from scratch costs millions of dollars and months of GPU time. We can't afford to re-train the model every time our leave policy changes. We need a dynamic solution.

Step 2: Give the Employee a Manual (Knowledge Base)
Instead of forcing the employee to memorize everything (which is like training/fine-tuning a model), you simply hand them an Employee Handbook (a PDF or a Knowledge Base).
This manual contains your Leave Policy, Office Rules, Holidays, and Working Hours. Now, when asked, the employee can look it up and answer correctly. In AWS, this is exactly what Amazon Bedrock Knowledge Bases do.

Step 3: But AI Cannot Read 500 Pages Every Time (RAG)
Imagine every time a customer asks a question, the employee starts reading all 500 pages of the manual from page 1. That's impossible and too slow.
Instead, the employee looks at the index, finds only the relevant page, and reads just that section to answer the question. This is exactly what Retrieval-Augmented Generation (RAG) does.
Trainer Context/Deep Dive:
An LLM has a limited memory per conversation (e.g., 4K, 128K, or 200K tokens). You physically cannot stuff a massive enterprise database into the prompt. RAG solves the token limit issue and saves inference costs.

Step 4 & 5: How Does AI Find the Right Page? (Embeddings)
Suppose your handbook has Office Timing on page 12, Leave Policy on page 25, and Salary on page 150. When a customer asks, 'Can I take maternity leave?', the AI immediately jumps to Page 25. How? By using Embeddings.
What are Embeddings? Imagine every document, paragraph, or concept becomes GPS coordinates. Similar topics stay close together on this map. For example, 'Leave Policy' and 'Maternity Leave' will have coordinates very close to each other, while 'Tea' and 'Milk' will be close to each other, but far away from 'Salary'.
When someone asks a question, the AI converts the question into coordinates and searches for nearby coordinates. That is semantic search.

Step 6: Where are these Coordinates Stored? (Vector Database)
These coordinates are stored inside a Vector Database. Think of it like Google Maps for your data.
Just as Google Maps stores Latitude and Longitude to find places, a Vector Database stores Embeddings to find information.
Examples include: Amazon OpenSearch, Pinecone, FAISS, and ChromaDB.

Step 7: The Complete AI Flow

User asks a Question.
Convert the question into an Embedding (Numbers).
Perform a Vector Database Search.
Relevant Document/Text Chunk is Retrieved.
Combine Prompt + Context.
Send to the LLM.
LLM generates the Final Answer.

Step 8: Real AWS Architecture
A standard enterprise architecture on AWS for this looks like:
• 1. Documents (PDFs) stored in Amazon S3.
• 2. AWS Knowledge Bases process the data.
• 3. Amazon Titan Embeddings converts text to vectors.
• 4. Amazon OpenSearch Serverless acts as the Vector DB.
• 5. Amazon Bedrock routes the prompt to an LLM (like Claude or Titan).
• 6. The AI Chatbot delivers the response to the user.

Key Takeaways & Final Thoughts
• • AI doesn't magically know your data; it needs a manual.
• • RAG helps AI read only the relevant information.
• • Embeddings convert meaning into numbers to enable semantic matching.
• • Vector Databases are the search engines that quickly find similar information.
• • Amazon Bedrock + Knowledge Bases make building enterprise AI much easier by abstracting the heavy lifting.

Final Thought:
Think of AI as a brilliant employee. If you give it the right knowledge (S3/DBs), the right search system (Vector DB/Embeddings), and the right context (RAG via prompt engineering)—it becomes an exceptional assistant.

AWS Auto Scaling: Optimize Performance and Cost with Ease

Mohammed N Zubair — Thu, 20 Mar 2025 10:43:46 +0000

In today's dynamic cloud environment, ensuring application availability and cost efficiency is crucial. AWS Auto Scaling provides a seamless way to automatically adjust resources based on demand, optimizing performance while minimizing costs.

Auto Scaling options :

Dynamic
Predictive
Scheduled

Dynamic : Automatic scaling can be configured to be dynamic. For example, suppose that you have a web application that
currently runs on three instances. You do not want the CPU utilization of the auto scaling group to exceed 70
percent for more than 2 minutes. You can configure your auto scaling group to scale automatically to meet this
need. The policy type determines how the scaling action is performed.

Predictive : AWS also provides predictive scaling
Predictive scaling uses machine learning models to predict your expected traffic (and Amazon EC2 usage), including daily and weekly patterns. These predictions use data that is collected from your actual Amazon EC2 usage and data points that are drawn from your own observations. The model needs historical data from at least 1 day to start making predictions. The model is re-evaluated every 24 hours to create a forecast for the next 48 hours.

Scheduled : By scaling based on a schedule, you can scale your application in response to predictable load changes. For
example, suppose that every week, the traffic to your web application starts to increase on Wednesday, remains partially
high on Thursday, and starts to decrease by Friday. In these situations, you can plan your scaling activities based on the predictable traffic patterns of your web application.

Note : loadfile.txt (copy the file content and create .py file in EC2 and paste. Now run .py file to increase CPU utilization temporarily)

Click here to Download .pdf step-by-step file

Click here to Download temporary (python) file.

Connect to your Linux instance from AWS console.

Mohammed N Zubair — Tue, 21 Jan 2025 07:57:59 +0000

🚀 Launching an EC2 Instance
🔗 Connect to Your EC2 Instance (Practice Only)
🛑 Terminating Your Instance

Click here to Download .pdf step-by-step file

Launching an EC2 Instance with Boto3 in Python

Mohammed N Zubair — Fri, 23 Aug 2024 07:02:08 +0000

In this example, we'll use the AWS SDK for Python (Boto3) to programmatically launch an EC2 instance. This script demonstrates how to create a session with your AWS credentials and then use that session to start an EC2 instance in your specified region.

Key Steps:

Session Creation: We begin by creating a session with our AWS credentials.
EC2 Client: Using this session, we establish an EC2 client to interact with the EC2 service.
Launching an Instance: We then launch an EC2 instance by specifying the AMI ID, instance type, key pair, security group, and subnet.

import boto3

# Create a session using your credentials
session = boto3.Session(
    aws_access_key_id='access key need to paste', #replace wit your access key
    aws_secret_access_key='sec access key need to paste', #replace with your sec access key
    region_name='ap-southeast-1' # Replace with your region name
)

# Create an EC2 client
ec2_client = session.client('ec2')

# Launch an EC2 instance
response = ec2_client.run_instances(
    ImageId='ami-0a6b545f62129c495',  # Replace with your AMI ID
    InstanceType='t2.micro',          # Replace with your instance type
    MinCount=1,
    MaxCount=1,
    KeyName='sinapore-mac',      # Replace with your key pair name
    SecurityGroupIds=['sg-064b056b2a7650e76'],  # Replace with your security group ID
    SubnetId='subnet-08237211566f4e5f5'  # Replace with your subnet ID
)

# Print the instance ID
instance_id = response['Instances'][0]['InstanceId']
print(f'Launched instance with ID: {instance_id}')

Web server installation / configuration on Amazon Linux machine.

Mohammed N Zubair — Thu, 01 Aug 2024 11:56:51 +0000

What Is a Web Server?

File servers, database servers, mail servers, and web servers use different kinds of server software. Each of these applications can access files stored on a physical server and use them for various purposes.

The job of a web server is to serve websites on the internet. To achieve that goal, it acts as a middleman between the server and client machines. It pulls content from the server on each user request and delivers it to the web.

The biggest challenge of a web server is to serve many different web users at the same time each of whom is requesting different pages. Web servers process files written in different programming languages such as PHP, Python, Java, and others.

They turn them to static HTML files and serve these files in the browser for web users. When you hear the word web server, think of it as the tool responsible for the proper server-client communication.

To download installation command click here

Steps to connect with putty & convert .pem to .ppk

Connect your Linux instance from Windows, using "Putty".

Mohammed N Zubair — Thu, 01 Aug 2024 11:42:18 +0000

Verify that the instance is ready
Install PuTTY on your local computer
Convert your private .pem key to .ppk using PuTTYgen

Kindly use this link to download step-by-step process .pdf file

Scenario based practices for securing an AWS S3 bucket.

Mohammed N Zubair — Sun, 07 Jul 2024 10:57:48 +0000

Scenario:

You have an AWS S3 bucket named my-example-bucket where you store sensitive documents. You want to ensure the bucket is secure according to AWS S3 best practices.

Solution Steps:

1. Enable Versioning:
Versioning helps protect against accidental deletion or modification of objects.

Action: Enable versioning on the my-example-bucket.
How: Using AWS Management Console:
Navigate to the S3 console.
Select my-example-bucket.
Click on the Properties tab.
Under Advanced settings, select Versioning.
Click Enable versioning.

2. Configure Bucket Policies:

Implement a bucket policy to restrict access based on the principle of least privilege.

Action: Create a bucket policy that allows only specific IAM users or roles to access the bucket.
Example Policy (replace my-example-bucket and arn:aws:iam::123456789012:user/authorized-user with your actual bucket name and IAM user ARN):

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789012:user/authorized-user"
},
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:DeleteObject"
],
"Resource": [
"arn:aws:s3:::my-example-bucket/*"
]
}
]
}

How: Using AWS Management Console:
Navigate to the S3 console.
Select my-example-bucket.
Click on the Permissions tab.
Click Bucket Policy.
Paste the JSON policy above, modifying it with your specific IAM user ARN and bucket name.

3. Enable Server-Side Encryption (SSE):

Encrypt data at rest to protect sensitive information stored in the bucket.

Action: Enable SSE for objects uploaded to my-example-bucket.
How: Using AWS Management Console:
Navigate to the S3 console.
Select my-example-bucket.
Click on the Properties tab.
Under Default encryption, click Edit.
Select AES-256 (SSE-S3) or AWS-KMS (SSE-KMS).
Click Save.

4. Enable Logging and Monitoring:
Enable access logging to track requests made to my-example-bucket.

Action: Enable logging to record access requests for audit and compliance purposes.
How: Using AWS Management Console:
Navigate to the S3 console.
Select my-example-bucket.
Click on the Properties tab.
Under Server access logging, click Edit.
Select Enable logging.
Specify a target bucket and prefix for storing log files.
Click Save.

5. Regular Audits and Reviews:
Regularly review access permissions, policies, and configurations for my-example-bucket to ensure security best practices are maintained.

Action: Schedule periodic audits to review bucket policies, IAM roles, and access logs.
How: Manually or using AWS Config and AWS CloudTrail for automated monitoring and auditing.

Summary:
By following these steps, you've implemented several AWS S3 security best practices for my-example-bucket:

Ensured data protection with versioning and encryption.
Controlled access with a bucket policy based on least privilege.
Enhanced visibility and accountability with access logging.

These practices help secure your sensitive documents stored in AWS S3 and mitigate risks associated with unauthorized access or accidental data loss.

Best Practices for S3 Security

Mohammed N Zubair — Sun, 07 Jul 2024 09:05:05 +0000

Bucket Policies: Restrict access using the principle of least privilege.
Encryption: Always enable SSE for data at rest. Use SSE-S3 or SSE-KMS based on your security and compliance requirements.
Access Logging: Enable logging to track access and monitor for unauthorized activities.
Versioning: Enable versioning to protect against accidental deletion or overwrite.
IAM: Use IAM roles and policies to control who can create, modify, or delete S3 resources.
Monitoring: Use Amazon CloudWatch for monitoring S3 access patterns and set up alerts for unusual activities.
Regular Audits: Conduct regular security audits and reviews of your S3 configurations.

Amazon VPC (Virtual Private Cloud)

Mohammed N Zubair — Sun, 31 Dec 2023 11:03:16 +0000

Amazon VPC is your network environment in the cloud. With Amazon VPC, you can launch AWS resources into a virtual network that you have defined.

VPCs deploy into one of the AWS Regions and can host resources from any Availability Zone within its Region.

Amazon VPC is designed to provide greater control over the isolation of your environments and their resources. With Amazon VPC, you can:

Select your own IP address range
Create subnets
Configure route tables and network gateways

_Following diagram will help to understand VPC and components with Login activity by DBA (database Admin) and normal user accessing website and database.
_

Note : To know step-by-step process Kindly click here “DOWNLOAD”