DEV Community: Ashwin Raiyani

AI That Writes vs AI That Acts: Understanding Generative and Agentic Intelligence

Ashwin Raiyani — Tue, 17 Feb 2026 02:53:59 +0000

Consider you are asking an AI to plan your dream vacation to Kedarnath.

Generative AI writes you a beautiful 10-day itinerary — complete with spots, temple visits, and temple schedules.

Agentic AI books the flights, reserves the stay, adds calendar reminders, and sends you a packing list based on the weather forecast.

Same question. Wildly different outcomes.

Welcome to the most important distinction in modern AI — and by the end of this post, you'll understand it better than most people in tech. Let's dive in.

What is Generative AI?
What is Agentic AI?
Side-by-Side Comparison
How They Work Under the Hood
Real-World Use Cases
Mini Walkthrough: See Them in Action
Can They Work Together?
Where is This All Heading?
Pro Tips for Beginners
Wrapping Up

Generative AI: The Creative Genius

Generative AI is the AI that creates. It generates new content — text, images, music, code, video — based on patterns it learned from massive datasets.

Think of it as the world's most well-read intern. It's absorbed billions of documents, images, and conversations, and when you ask it something, it generates a response by predicting what should come next.

Examples you've probably already used:

ChatGPT / Claude → Generates text responses to your prompts
DALL·E / Midjourney → Generates images from descriptions
Suno / Udio → Generates music from text
GitHub Copilot → Generates code suggestions as you type

Key Characteristics:

✅ Creates new content (doesn't just retrieve existing stuff)
✅ Works from a single prompt → single output
✅ Excellent at language, creativity, and pattern recognition
⚠️ Doesn't do anything in the real world — it responds
⚠️ Needs a human to act on its output

Think of it this way: Generative AI is like a brilliant advisor sitting across the table from you. It gives phenomenal advice. But it never gets up from the chair.

Agentic AI: The Autonomous Doer

Agentic AI is the AI that acts. It doesn't just generate a response — it plans, reasons, uses tools, and executes multi-step tasks autonomously (or semi-autonomously).

It's like giving that brilliant advisor a laptop, a phone, API keys, and saying: "Don't just tell me what to do — go do it."

Examples that are changing the game:

GitHub Copilot Coding Agent → Receives an issue, writes code, opens a PR — autonomously
AI Research Agents → Browse the web, read papers, synthesize findings, write reports
Data Analysis Agents → Connect to your database, run queries, generate insights, create dashboards
Customer Support Agents → Read tickets, check order status, issue refunds — end to end

Key Characteristics:

✅ Plans a sequence of steps to achieve a goal
✅ Uses tools (APIs, browsers, databases, file systems)
✅ Makes decisions and adapts on the fly
✅ Can operate in loops — evaluate results, retry, self-correct
⚠️ Requires careful guardrails and human oversight
⚠️ More complex to build and manage

Think of it this way: Agentic AI is that advisor who stood up, grabbed the car keys, and started handling things. Powerful? Absolutely. Needs supervision? Also absolutely.

The Big Comparison Table

Feature	Generative AI	Agentic AI
Primary Function	Creates content	Takes actions & completes tasks
Interaction Model	Prompt → Response (one-shot)	Goal → Plan → Execute → Evaluate (loop)
Autonomy	Low (human drives each step)	High (AI drives multi-step workflows)
Tool Usage	Rarely (mostly internal knowledge)	Extensively (APIs, browsers, databases)
Memory	Limited to context window	Can maintain long-term task memory
Self-Correction	Only if you re-prompt it	Built-in reflection & retry loops
Example	"Write me a marketing email"	"Run my entire email campaign for Q1"
Complexity to Build	Moderate	High
Risk Level	Lower (output only)	Higher (real-world actions)
Human Role	Reviewer of output	Supervisor of process

⚙️ How They Work Under the Hood

Generative AI — The Architecture

[Your Prompt] → [Large Language Model (LLM)] → [Generated Output]

It's (conceptually) a one-way street:

You provide a prompt
The model processes it through billions of parameters
It predicts the most likely next tokens (words/pixels/notes)
You get a single output

The magic is in the training data and the model architecture (Transformers, Diffusion Models, etc.). But once it gives you the output, it's done. Ball's in your court.

Agentic AI — The Architecture

[Your Goal]
    → [Planner: Break goal into steps]
    → [Step 1: Use Tool A] → [Evaluate result]
    → [Step 2: Use Tool B] → [Evaluate result]
    → [Step 3: Reflect — is this working?]
    → [Adjust plan if needed]
    → [Final Output / Action]

It's a loop — often called a ReAct loop (Reasoning + Acting):

Reason about what needs to happen
Act using available tools
Observe the results
Repeat until the goal is achieved (or a limit is reached)

Key Insight: Agentic AI almost always has a Generative AI model at its core (like GPT-4, Claude, or Gemini). The "agentic" part is the scaffolding around it — the planning, tool use, memory, and execution layer.

🌍 Real-World Use Cases

Generative AI Shines When...

Scenario	What It Does
✍️ Writing a blog post	Generates a draft from your outline
🖼️ Creating marketing visuals	Produces images from text descriptions
💻 Code completion	Suggests the next line as you type
📝 Summarizing documents	Condenses a 50-page PDF into key points
🌐 Translating content	Converts text between languages with nuance
🎓 Explaining concepts	Breaks down quantum physics like you're five

Agentic AI Shines When...

Scenario	What It Does
Fixing a GitHub issue	Reads the issue, explores the codebase, writes & tests a fix, opens a PR
Market research	Browses 20 sources, compares data, generates a report with citations
Personal shopping	Checks prices across sites, applies coupons, places the order
DevOps automation	Detects a failing deployment, reads logs, applies a fix, re-deploys
Meeting scheduling	Checks everyone's calendars, finds a slot, sends invites, books a room
Data pipeline management	Monitors, troubleshoots, and repairs ETL pipelines autonomously

Mini Walkthrough: See Them in Action

Let's make this real. Imagine you're a developer and you've found a bug in your open source project.

Scenario: "The login button isn't working on mobile" 🐛📱

With Generative AI (e.g., ChatGPT):

You: "The login button on our React app doesn't respond to taps on mobile. Here's the component code. What's wrong?"

AI: "The issue is likely that your onClick handler doesn't account for touch events on mobile. Here's a fix — add an onTouchEnd handler or use a button element instead of a div with a click handler..."

// AI-suggested fix
<button
  className="login-btn"
  onClick={handleLogin}
  type="button"
>
  Log In
</button>

Result: You got a great answer. Now you need to:

Open your IDE
Find the right file
Make the change
Test it
Commit and push
Open a PR

With Agentic AI (e.g., GitHub Copilot Coding Agent):

You: Assign the GitHub issue "Login button unresponsive on mobile" to Copilot.

Agent (thinking):

Read the issue description and comments
Search the codebase for login-related components
Identify that LoginButton.jsx uses a <div> with onClick
Refactor to use a <button> with proper touch handling
Run existing tests and verify they pass
Open a pull request with a clear description of the fix

Result: You wake up to a ready-to-review PR. You read the diff, approve it, and merge.

See the difference? Same problem. Generative AI gave you the knowledge. Agentic AI gave you the solution, implemented.

Two Paradigms of AI: Generative and Agentic: Can They Work Together?

Absolutely. And this is where the real magic happens.

In fact, most powerful AI systems in 2026 are both generative AND agentic. The generative model is the brain. The agentic framework is the body.

Here's a real-world combo:

📋 You: "Prepare a weekly engineering report for my team"

Agentic Layer:
   ├── Step 1: Query GitHub API for merged PRs this week (Tool Use)
   ├── Step 2: Query Jira for completed tickets (Tool Use)
   ├── Step 3: Pull deployment logs for uptime stats (Tool Use)
   └── Step 4: Pass all data to Generative AI ↓

Generative Layer:
   └── Writes a beautifully formatted, human-readable report
       with highlights, shoutouts, and key metrics

Agentic Layer (continued):
   ├── Step 5: Posts report to Slack #engineering channel (Tool Use)
   └── Step 6: Emails a copy to the VP of Engineering (Tool Use)

✅ Done. You didn't lift a finger.

This is the pattern: Agentic AI orchestrates. Generative AI creates. Together, they're unstoppable.

Where is This All Heading?

Here's a quick look at the evolution:

2022 │ Generative AI goes mainstream (ChatGPT launches)
     │
2023 │ Developers start building "chains" (LangChain, etc.)
     │
2024 │ Agentic AI emerges (AutoGPT, CrewAI, OpenAI Assistants)
     │
2025 │ Production-grade agents arrive (GitHub Copilot Agent,
     │    Google's Project Mariner, Anthropic's Computer Use)
     │
2026 │ Multi-agent systems go mainstream
(now)│    Agents collaborate with EACH OTHER
     │
2027+│ Autonomous agent ecosystems?
     │    Agents that hire other agents? 👀

We're currently in the "agents in production" era. The question isn't if agentic AI will impact your work — it's when (spoiler: probably already has).

💡 Pro Tips for Beginners

Tip #1: Start With Generative, Graduate to Agentic

Don't try to build autonomous agents on day one. Get comfortable with prompting, understand how LLMs think, and then add tool use and planning layers.

Tip #2: "Agentic" Doesn't Mean "No Humans"

The best agentic systems keep humans in the loop. Think autopilot, not unmanned rocket. You're the pilot — the AI handles the tedious parts.

Tip #3: Learn the Tooling Ecosystem

Get familiar with these building blocks:

LLM APIs (OpenAI, Anthropic, Google) — the brains

Agent Frameworks (LangGraph, CrewAI, AutoGen) — the skeleton

Tool Libraries (function calling, MCP, API integrations) — the hands

Guardrails (output validation, approval workflows) — the seatbelts

Tip #4: Watch for the "Agent Tax"

Agentic AI makes lots of API calls (LLM calls, tool calls, retry loops). Costs can add up fast. Always set budgets and limits on your agent loops.

Tip #5: Build Your First Agent This Weekend

Seriously. Here's a simple starter:

Pick a repetitive task you do weekly

Break it into 3-5 steps

Use an LLM + function calling to automate it

Add a simple loop for error handling

You just built an agent.

Quick Reference Cheat Sheet

┌─────────────────────────────────────────────────────┐
│              AI PARADIGM CHEAT SHEET                │
├─────────────────────────────────────────────────────┤
│                                                     │
│   GENERATIVE AI           AGENTIC AI           │
│  ─────────────────         ──────────────           │
│  • Creates content         • Completes tasks        │
│  • Single turn             • Multi-step loops       │
│  • You act on output       • It acts for you        │
│  • Prompt → Response       • Goal → Plan → Execute  │
│  • Low risk                • Needs guardrails       │
│  • Easy to start           • Harder to build        │
│                                                     │
│   BEST TOGETHER:                                  │
│  Agentic orchestrates + Generative creates          │
│  = AI that thinks AND does                          │
│                                                     │
└─────────────────────────────────────────────────────┘

🏁 Wrapping Up

If there's one thing to remember from this post, it's this:

Generative AI is your creative partner. Agentic AI is your autonomous teammate. The future runs on both.

We're living in a remarkable time. Two years ago, "AI" meant chatbots that could barely hold a conversation. Today, AI agents are writing code, conducting research, and managing workflows — while generative models create art, music, and prose that rivals human creativity.

Start with a prompt. Build a small agent. Break things. Learn. Iterate.

The AI revolution isn't something that's happening to you. It's something you can be a part of — starting today.

Call to Action

** Drop a comment** — Are you Team Generative, Team Agentic, or Team Both?
** Build something** — Try the weekend agent challenge from Pro Tip #5

Anomalies to Insights: CloudWatch & SageMaker for Smarter Observability

Ashwin Raiyani — Wed, 10 Sep 2025 17:52:27 +0000

📊 Technical Deep Dive • ⏱️ 15 min read • 🎯 Beginner to Intermediate

The 3 AM Model Meltdown Scenario
Why Traditional Monitoring Fails ML
CloudWatch Fundamentals for ML
SageMaker's Observability Superpowers
Hands-On: Building Your Pipeline
Real-World Success Story
Best Practices & Pro Tips

The 3 AM Model Meltdown Scenario

Picture this: It's 3 AM. Your phone buzzes with alerts. Your machine learning model's accuracy just plummeted from 95% to 60%, and you have absolutely no idea why. Your recommendation engine is now suggesting winter coats to customers in Miami, and your fraud detection system just flagged every legitimate transaction as suspicious.

Sound familiar? If you've worked with ML models in production, you've probably lived through this nightmare at least once. The traditional approach of "deploy and hope for the best" simply doesn't cut it in the world of machine learning, where models can drift silently and data can shift without warning.

Here's the good news: AWS CloudWatch and SageMaker have evolved into a powerful observability duo that can transform those panic-inducing 3 AM alerts into proactive insights. Instead of reactive firefighting, you'll have a crystal-clear view of your model's health, performance, and behavior patterns.

🎯 What You'll learn Today

By the end of this guide, you'll understand how to set up comprehensive ML observability that:

Catches issues before they impact users
Provides actionable insights for model improvement
Turns monitoring from a necessary evil into your competitive advantage

Why Traditional Monitoring Falls Short

Traditional application monitoring focuses on infrastructure metrics: CPU usage, memory consumption, response times. These metrics work great for web applications, but they tell you virtually nothing about the health of your machine learning models.

Consider Sarah, a data scientist at a fintech startup. Her fraud detection model worked perfectly during testing, achieving 97% accuracy on historical data. But three months after deployment, something strange started happening:

📉 The Silent Killer: Model Drift

Month 1: Model accuracy: 97% ✅

Month 2: Model accuracy: 94% ⚠️ (within acceptable range)

Month 3: Model accuracy: 89% ❌ (significant degradation)

The Kicker: All infrastructure metrics remained normal. CPU at 45%, memory at 60%, response time under 200ms. Traditional monitoring gave zero indication of the problem.

This scenario highlights the unique challenges of ML observability:

Challenge	Description
🔄 Data Drift	Input data patterns change over time, making your model less effective
📊 Concept Drift	The relationship between inputs and outputs shifts in the real world
🎯 Performance Degradation	Model accuracy declines gradually, often going unnoticed
🔍 Bias Introduction	Models develop unexpected biases as new data patterns emerge

⚡ The ML Monitoring Gap

A study by Algorithmia found that 55% of companies have never deployed an ML model to production, and of those who have, 40% struggle with model monitoring and maintenance. The infrastructure runs fine, but the AI brain inside is slowly degrading.

This is where CloudWatch and SageMaker's observability features become game-changers. They bridge the gap between traditional infrastructure monitoring and ML-specific observability, giving you insights that actually matter for intelligent systems.

CloudWatch Fundamentals: Your ML Observatory

Think of AWS CloudWatch as your mission control center for ML operations. While it started as a traditional infrastructure monitoring service, it has evolved into a comprehensive observability platform that understands the nuances of machine learning workloads.

Core Components for ML Monitoring

Component	Purpose
📊 Custom Metrics	Track model-specific KPIs like accuracy, precision, recall, and business metrics
📝 Structured Logs	Capture prediction inputs, outputs, and metadata for analysis
🚨 Intelligent Alarms	Set up alerts based on ML performance thresholds, not just infrastructure
📈 Rich Dashboards	Visualize model performance alongside infrastructure metrics

Setting Up Your First ML Metric

Let's start with something practical. Here's how you'd track model accuracy in real-time:

import boto3
import json
from datetime import datetime

cloudwatch = boto3.client('cloudwatch')

def log_model_performance(model_name, accuracy, precision, recall):
    """
    Log ML model performance metrics to CloudWatch
    """
    try:
        # Create custom metrics for model performance
        cloudwatch.put_metric_data(
            Namespace='ML/ModelPerformance',
            MetricData=[
                {
                    'MetricName': 'Accuracy',
                    'Dimensions': [
                        {
                            'Name': 'ModelName',
                            'Value': model_name
                        }
                    ],
                    'Value': accuracy,
                    'Unit': 'Percent',
                    'Timestamp': datetime.utcnow()
                },
                {
                    'MetricName': 'Precision',
                    'Dimensions': [
                        {
                            'Name': 'ModelName',
                            'Value': model_name
                        }
                    ],
                    'Value': precision,
                    'Unit': 'Percent'
                },
                {
                    'MetricName': 'Recall',
                    'Dimensions': [
                        {
                            'Name': 'ModelName',
                            'Value': model_name
                        }
                    ],
                    'Value': recall,
                    'Unit': 'Percent'
                }
            ]
        )
        print(f"Metrics logged for {model_name}")
    except Exception as e:
        print(f"Error logging metrics: {e}")

# Usage in your ML pipeline
log_model_performance(
    model_name="fraud-detection-v2",
    accuracy=94.2,
    precision=93.8,
    recall=95.1
)

💡 Pro Tip: Namespace Organization

Use hierarchical namespaces like "ML/ModelPerformance", "ML/DataQuality", and "ML/BusinessImpact". This makes it easier to organize dashboards and set up alerts as your ML operations scale.

Understanding CloudWatch Costs for ML

CloudWatch pricing can surprise newcomers, especially when monitoring ML workloads that generate lots of metrics. Here's what you need to know:

First 10 custom metrics per month: Free
Additional custom metrics: $0.30 per metric per month
API requests: $0.01 per 1,000 requests
Dashboard: $3.00 per month per dashboard
Logs ingestion: $0.50 per GB ingested

💰 Cost Optimization Strategy

For a typical ML application monitoring 5 models with 20 metrics each, expect around $30-50/month in CloudWatch costs. Use log sampling and metric aggregation to keep costs reasonable while maintaining observability.

SageMaker's Observability Superpowers

While CloudWatch provides the monitoring infrastructure, SageMaker brings ML-native observability features that understand your models at a deep level. Think of it as having a data scientist watching your models 24/7.

SageMaker Model Monitor: The Game Changer

SageMaker Model Monitor is like having a vigilant guardian for your ML models. It continuously analyzes your model's inputs and outputs, comparing them against a baseline to detect four critical types of drift:

Monitor Type	What It Detects
📊 Data Quality	Missing values, type mismatches, constraint violations
🎯 Model Quality	Accuracy, precision, recall against ground truth when available
⚖️ Bias Drift	Identifies if your model develops unfair biases over time
🔄 Feature Attribution	Tracks which features drive predictions and how that changes

Setting Up Data Quality Monitoring

Let's walk through setting up data quality monitoring for a real-time endpoint:

import sagemaker
from sagemaker.model_monitor import DefaultModelMonitor
from sagemaker.model_monitor.dataset_format import DatasetFormat

# Initialize SageMaker session
sagemaker_session = sagemaker.Session()

# Create a Model Monitor instance
data_quality_monitor = DefaultModelMonitor(
    role=execution_role,
    instance_count=1,
    instance_type='ml.m5.xlarge',
    volume_size_in_gb=20,
    max_runtime_in_seconds=3600,
    sagemaker_session=sagemaker_session
)

# Suggest baseline using training data
baseline_job = data_quality_monitor.suggest_baseline(
    baseline_dataset=training_data_uri,
    dataset_format=DatasetFormat.csv(header=True),
    output_s3_uri=f"s3://{bucket}/monitoring/baseline",
    wait=True
)

print(f"Baseline job completed: {baseline_job.job_name}")

# Create monitoring schedule
monitoring_schedule = data_quality_monitor.create_monitoring_schedule(
    monitor_schedule_name="fraud-model-data-quality-schedule",
    endpoint_input=endpoint_name,
    output_s3_uri=f"s3://{bucket}/monitoring/reports",
    statistics=baseline_job.baseline_statistics(),
    constraints=baseline_job.suggested_constraints(),
    schedule_cron_expression="cron(0 * * * ? *)",  # Every hour
    enable_cloudwatch_metrics=True
)

print(f"Monitoring schedule created: {monitoring_schedule.schedule_name}")

🎯 Baseline Best Practices

Use your most recent, representative training data for baselines. Avoid using data from model development or early experiments. The baseline should reflect the data quality and patterns your model expects in production.

Understanding SageMaker's Detection Algorithms

SageMaker uses sophisticated statistical methods to detect drift:

Kolmogorov-Smirnov Test: Compares distributions of continuous features
Chi-Square Test: Detects changes in categorical feature distributions
Statistical Distance Metrics: Measures how far current data drifts from baseline
Constraint Validation: Checks data types, ranges, and business rules

Example Drift Metrics:

Data Quality Score:        0.92 ✅
Feature Drift Score:       0.78 ⚠️  
Missing Value Rate:        2.1% ✅
Constraint Violations:     5    ❌

These metrics automatically flow into CloudWatch, where you can set up alerts and create dashboards that give you a holistic view of your model ecosystem.

Hands-On: Building Your Complete Observability Pipeline

Now let's put it all together. We'll build a comprehensive monitoring pipeline for a fraud detection model that combines CloudWatch's flexibility with SageMaker's ML-specific capabilities.

Step-by-Step Implementation

Step 1: Deploy Your Model with Monitoring Enabled

First, we'll deploy a SageMaker endpoint with data capture enabled. This is crucial for monitoring - you need to capture prediction requests and responses.

from sagemaker.model import Model
from sagemaker.predictor import Predictor

# Create model with monitoring configuration
model = Model(
    image_uri=container_uri,
    model_data=model_artifacts_uri,
    role=execution_role,
    name="fraud-detection-model"
)

# Deploy with data capture configuration
predictor = model.deploy(
    initial_instance_count=1,
    instance_type='ml.m5.large',
    endpoint_name='fraud-detection-endpoint',
    data_capture_config={
        'EnableCapture': True,
        'InitialSamplingPercentage': 100,  # Capture 100% for demo
        'DestinationS3Uri': f's3://{bucket}/datacapture',
        'CaptureOptions': [
            {'CaptureMode': 'Input'},
            {'CaptureMode': 'Output'}
        ]
    }
)

Step 2: Create Custom CloudWatch Metrics

Set up custom metrics that track business-relevant KPIs alongside technical performance metrics.

import boto3
from datetime import datetime

cloudwatch = boto3.client('cloudwatch')

def track_business_metrics(predictions, ground_truth=None):
    """Track business and model performance metrics"""

    # Calculate business metrics
    fraud_rate = sum(1 for p in predictions if p['fraud_probability'] > 0.7) / len(predictions)
    avg_transaction_amount = sum(p['transaction_amount'] for p in predictions) / len(predictions)

    # Model performance metrics (if ground truth available)
    if ground_truth:
        accuracy = calculate_accuracy(predictions, ground_truth)
        precision = calculate_precision(predictions, ground_truth)

        # Log model performance
        cloudwatch.put_metric_data(
            Namespace='FraudDetection/ModelPerformance',
            MetricData=[
                {
                    'MetricName': 'Accuracy',
                    'Value': accuracy,
                    'Unit': 'Percent',
                    'Timestamp': datetime.utcnow()
                },
                {
                    'MetricName': 'Precision',
                    'Value': precision,
                    'Unit': 'Percent'
                }
            ]
        )

    # Log business metrics
    cloudwatch.put_metric_data(
        Namespace='FraudDetection/BusinessMetrics',
        MetricData=[
            {
                'MetricName': 'FraudRate',
                'Value': fraud_rate * 100,
                'Unit': 'Percent'
            },
            {
                'MetricName': 'AvgTransactionAmount',
                'Value': avg_transaction_amount,
                'Unit': 'None'
            }
        ]
    )

Step 3: Configure SageMaker Model Monitor

Set up comprehensive monitoring that tracks data quality, model quality, and bias drift.

from sagemaker.model_monitor import DefaultModelMonitor, ModelQualityMonitor
from sagemaker.model_monitor.dataset_format import DatasetFormat

# Data Quality Monitor
data_monitor = DefaultModelMonitor(
    role=execution_role,
    instance_count=1,
    instance_type='ml.m5.xlarge',
    volume_size_in_gb=20,
    max_runtime_in_seconds=3600
)

# Create baseline for data quality
baseline_job = data_monitor.suggest_baseline(
    baseline_dataset=training_data_uri,
    dataset_format=DatasetFormat.csv(header=True),
    output_s3_uri=f"s3://{bucket}/monitoring/data-quality-baseline"
)

# Model Quality Monitor (requires ground truth)
model_quality_monitor = ModelQualityMonitor(
    role=execution_role,
    instance_count=1,
    instance_type='ml.m5.xlarge',
    volume_size_in_gb=20,
    max_runtime_in_seconds=3600
)

# Create model quality baseline
model_baseline_job = model_quality_monitor.suggest_baseline(
    baseline_dataset=validation_data_uri,
    dataset_format=DatasetFormat.csv(header=True),
    output_s3_uri=f"s3://{bucket}/monitoring/model-quality-baseline",
    problem_type='BinaryClassification',
    inference_attribute='prediction',
    probability_attribute='fraud_probability',
    ground_truth_attribute='is_fraud'
)

# Create monitoring schedules
data_quality_schedule = data_monitor.create_monitoring_schedule(
    monitor_schedule_name="fraud-model-data-quality",
    endpoint_input='fraud-detection-endpoint',
    output_s3_uri=f"s3://{bucket}/monitoring/data-quality-reports",
    statistics=baseline_job.baseline_statistics(),
    constraints=baseline_job.suggested_constraints(),
    schedule_cron_expression="cron(0 */2 * * ? *)",  # Every 2 hours
    enable_cloudwatch_metrics=True
)

model_quality_schedule = model_quality_monitor.create_monitoring_schedule(
    monitor_schedule_name="fraud-model-quality",
    endpoint_input='fraud-detection-endpoint',
    output_s3_uri=f"s3://{bucket}/monitoring/model-quality-reports",
    statistics=model_baseline_job.baseline_statistics(),
    constraints=model_baseline_job.suggested_constraints(),
    schedule_cron_expression="cron(0 */6 * * ? *)",  # Every 6 hours
    enable_cloudwatch_metrics=True
)

Step 4: Set Up Intelligent Alerts

Create CloudWatch alarms that trigger when model performance degrades or data drift is detected.

import boto3

cloudwatch = boto3.client('cloudwatch')
sns = boto3.client('sns')

# Create SNS topic for alerts
topic_response = sns.create_topic(Name='ml-model-alerts')
topic_arn = topic_response['TopicArn']

# Subscribe email to topic
sns.subscribe(
    TopicArn=topic_arn,
    Protocol='email',
    Endpoint='your-email@company.com'
)

# Create alarm for model accuracy drop
cloudwatch.put_metric_alarm(
    AlarmName='FraudModel-AccuracyDrop',
    ComparisonOperator='LessThanThreshold',
    EvaluationPeriods=2,
    MetricName='Accuracy',
    Namespace='FraudDetection/ModelPerformance',
    Period=3600,  # 1 hour periods
    Statistic='Average',
    Threshold=90.0,  # Alert if accuracy drops below 90%
    ActionsEnabled=True,
    AlarmActions=[topic_arn],
    AlarmDescription='Alert when model accuracy drops significantly',
    Unit='Percent'
)

# Create alarm for data drift
cloudwatch.put_metric_alarm(
    AlarmName='FraudModel-DataDrift',
    ComparisonOperator='GreaterThanThreshold',
    EvaluationPeriods=1,
    MetricName='feature_baseline_drift_age',
    Namespace='aws/sagemaker/Endpoints/data-metrics',
    Period=3600,
    Statistic='Average',
    Threshold=0.2,  # Alert if drift score > 0.2
    ActionsEnabled=True,
    AlarmActions=[topic_arn],
    AlarmDescription='Alert when significant data drift detected'
)

🚀 Implementation Tips

Start with 100% data capture, then reduce sampling as you understand patterns
Set up staging environment monitoring first to test your configuration
Use CloudFormation or CDK to make your monitoring setup reproducible
Configure different alert thresholds for different times (business hours vs. nights)
Include model version information in all metrics for easier debugging

Real-World Success Story: E-commerce Recommendation Recovery

Let me share a real success story that demonstrates the power of comprehensive ML observability. TechStyle Fashion, an e-commerce platform, was experiencing mysterious drops in click-through rates for their recommendation engine.

🛍️ The Challenge

Initial Problem: Recommendation click-through rates dropped from 8.2% to 5.1% over two weeks

Traditional Monitoring: Infrastructure showed no issues - all green lights

Business Impact: $300K weekly revenue loss from reduced engagement

Time to Detection: 2 weeks (discovered during monthly business review)

The Investigation Process

With CloudWatch and SageMaker monitoring in place, here's how they would have caught and resolved this issue in hours, not weeks:

1. Automatic Drift Detection

SageMaker Model Monitor detected significant drift in the "season" feature. The model was trained on spring/summer data, but autumn product launches changed the feature distribution.

Season Feature Drift:      0.89 ❌
Category Distribution:     0.34 ⚠️
Click-Through Rate:        5.1% ❌

2. Business Impact Correlation

Custom CloudWatch metrics showed the correlation between drift detection and business KPIs, making the impact immediately visible to both technical and business teams.

3. Automated Alert and Response

The drift alert triggered an automated workflow that:

Notified the ML team via Slack integration
Triggered automated retraining with recent data
Switched to a fallback popularity-based recommender
Generated a detailed drift report for analysis

📈 The Results

Detection Time: 2 hours (vs. 2 weeks previously)

Resolution Time: 6 hours (automated retraining + validation)

Revenue Saved: ~$280K by catching the issue early

Customer Experience: Seamless transition with fallback recommender

Key Lessons Learned

This case study highlights several critical observability principles:

Monitor Business Metrics: Technical metrics alone miss the business impact
Seasonal Awareness: Models need monitoring that understands business cycles
Automated Response: Fast detection means nothing without fast response
Fallback Strategies: Always have a simpler backup when the complex model fails
Cross-team Visibility: Business and technical teams need shared dashboards

Best Practices & Advanced Optimization

After implementing hundreds of ML monitoring systems, here are the battle-tested best practices that separate successful deployments from maintenance nightmares:

Cost Optimization Strategies

Strategy	Description
📊 Smart Sampling	Use stratified sampling for data capture. Monitor 100% of high-value transactions, 10% of standard ones
⏰ Adaptive Frequency	Increase monitoring frequency during model updates or business events, reduce during stable periods
🎯 Metric Prioritization	Focus on metrics that drive business decisions. Nice-to-have metrics can be expensive at scale
📦 Batch Processing	Aggregate and batch metric updates to reduce API costs and improve performance

Alert Fatigue Prevention

Nothing kills monitoring faster than alerts that cry wolf. Here's how to keep your alerts meaningful:

def create_smart_alarm(metric_name, threshold_config):
    """
    Create context-aware alarms that adjust based on time and business context
    """

    # Different thresholds for business hours vs off-hours
    business_hours_threshold = threshold_config['business_hours']
    off_hours_threshold = threshold_config['off_hours']

    # Create business hours alarm
    cloudwatch.put_metric_alarm(
        AlarmName=f'{metric_name}-BusinessHours',
        ComparisonOperator='LessThanThreshold',
        EvaluationPeriods=2,
        MetricName=metric_name,
        Namespace='ML/ModelPerformance',
        Period=1800,  # 30 minutes
        Statistic='Average',
        Threshold=business_hours_threshold,
        ActionsEnabled=True,
        AlarmActions=[high_priority_topic_arn],
        TreatMissingData='notBreaching'
    )

# Usage
create_smart_alarm('Accuracy', {
    'business_hours': 92.0,  # Stricter during business hours
    'off_hours': 88.0        # More lenient off-hours
})

Advanced Integration Patterns

CI/CD Integration: Include monitoring setup in your deployment pipelines
A/B Testing Awareness: Configure monitoring to handle multiple model versions
Data Pipeline Monitoring: Track data quality upstream from your models
Multi-Region Deployment: Aggregate metrics across regions for global view
Compliance Tracking: Monitor bias and fairness metrics for regulatory compliance

Team Workflow Integration

The best monitoring system is useless if your team doesn't know how to use it effectively:

🎯 Recommended Team Responsibilities

Data Scientists: Define meaningful metrics and thresholds based on model behavior

ML Engineers: Implement and maintain monitoring infrastructure

DevOps: Manage alerting, dashboards, and incident response

Product Managers: Define business impact metrics and acceptable performance ranges

Data Engineers: Ensure data quality monitoring upstream

# ML Model Monitoring Runbook
model_name: "fraud-detection-v2"
owner: "ml-platform-team"

monitoring_config:
  data_quality:
    frequency: "every 2 hours"
    alert_threshold: 0.3
    escalation_path: ["ml-engineer", "data-scientist", "team-lead"]

  model_performance:
    metrics: ["accuracy", "precision", "recall", "f1_score"]
    business_hours_threshold: 92.0
    off_hours_threshold: 88.0

incident_response:
  severity_1: "Model accuracy < 85%"
    - immediate_action: "Switch to fallback model"
    - notification: "Page on-call engineer"
    - timeline: "Resolve within 1 hour"

🚀 Ready to Transform Your ML Observability?

You now have everything you need to build world-class observability for your machine learning systems. The combination of CloudWatch's flexibility and SageMaker's ML-native features gives you superpowers that most data teams only dream of.

Your Next Steps:

Start with one model and implement basic data quality monitoring
Add custom business metrics that matter to your stakeholders
Set up intelligent alerts that won't wake you up at 3 AM for false positives
Build dashboards that tell the story of your model's health
Scale your monitoring approach across your entire ML portfolio

🎓 Additional Learning Resources

Want to dive deeper? Here are curated resources to accelerate your ML observability journey:

Resource Type	Recommendations
📚 AWS Documentation	SageMaker Model Monitor User Guide, CloudWatch Custom Metrics API Reference
🛠️ Hands-On Labs	AWS SageMaker Workshop: Model Monitor modules, CloudWatch Container Insights labs
📺 Video Learning	re:Invent sessions on ML Operations, AWS Architecture Center patterns
🏗️ Reference Architectures	AWS MLOps Workshop, SageMaker deployment best practices guide

What's your biggest ML monitoring challenge? Share your experiences in the comments below, and let's help each other build more reliable intelligent systems!

# 🚀 Demystifying AWS: A Hands-On Journey Through Cloud Economics and Global Infrastructure 🌍💡

Ashwin Raiyani — Mon, 16 Jun 2025 17:41:06 +0000

What happens when a room full of curious learners' minds dives into the vast world of AWS? You get a lively session that blends cloud economics, global infrastructure, and a healthy dose of hands-on discovery.

This 2-hour expert session was specially crafted for learners' — aligning with AWS Cloud Practitioner essentials — and covered:

💸 AWS Cloud Economics & Billing
🌍 AWS Global Infrastructure Overview
💻 Hands-on Demos using the Free Tier

📘 Why It Mattered

In today’s cloud-powered world, understanding how services are billed and where your data resides is essential for every future cloud user.

Our aim:

To empower learners with real-world skills in:

AWS pricing models
Cost estimation and budgeting
Global service deployment strategies

💸 Session 1: Understanding Cloud Costs with Analogies

We started with a simple analogy:

🧠 “Using AWS is like renting a laptop, a locker, and a courier — you pay for how long you use it (Compute), how much you store (Storage), and how far you send it (Outbound Data Transfer).”

🔍 Hands-On Demo: AWS Pricing Calculator & Budgets

Created a monthly budget (₹500 / $6)
Set actual (80%) and forecasted (90%) alerts
Simulated usage spikes to understand early warnings

⏰ Bonus Insight:

Forecasted alerts trigger before the budget is crossed — a smart way to avoid surprise bills.

🌐 Session 2: Exploring AWS Global Infrastructure

We visualised AWS’s worldwide backbone using:

Regions 🌎
Availability Zones 🏢
Edge Locations 🚀

🧭 Hands-On Demo: Global Map & Latency Testing

Explored infrastructure.aws
Measured ping latency from different regions via CloudPing.info
Discussed real-world applications like game hosting and CDN performance

✅ What Students Took Away

🔍 Skill	🌟 Outcome
AWS Console Navigation	✅ Confidence & familiarity
Budgeting	✅ Cost visibility & alerting
Infrastructure Concepts	✅ Region-aware thinking
Free Tier Exploration	✅ Risk-free experimentation

“I never thought billing and latency could be this hands-on and fun!” — Student feedback

🧪 Try It Yourself!

Want to try this on your own or in your classroom?
Here's what we used:

AWS Free Tier account
AWS Pricing Calculator
Budgets Dashboard
AWS Global Infrastructure Map
CloudPing.info

👩‍💻 Final Thoughts

This wasn’t just another theory session. It was about doing, understanding, and connecting concepts with curiosity. Whether you’re prepping for AWS Cloud Practitioner or just curious about cloud, remember:

Clarity in cloud starts with hands-on exploration.

⭐ Feel free to connect with me on LinkedIn or drop your questions in the comments.

#aws #cloudcomputing #devops #learners #learningbydoing

Announcing AWS Certified AI Practitioner and Certified Machine Learning Engineer - Associate: Unlocking New Career Possibilities

Ashwin Raiyani — Wed, 12 Jun 2024 06:00:48 +0000

Amazon Web Services (AWS) has recently introduced two new certifications aimed at empowering professionals to excel in the rapidly growing fields of Artificial Intelligence (AI) and Machine Learning (ML).

The certifications, AWS Certified AI Practitioner and AWS Certified Machine Learning Engineer – Associate, are designed to validate the skills and knowledge of professionals in various roles, from business and sales to IT and engineering.

In this blog, I will delve into the details of these certifications, their significance, and their benefits to professionals and organizations.

Certification Overview

The AWS Certified AI Practitioner certification is a foundational-level certification that focuses on understanding AI and ML concepts and recognising opportunities that benefit from AI and using AI tools responsibly. This certification is ideal for professionals familiar with AI/ML technologies on AWS but do not necessarily build AI/ML solutions on the platform. The certification is designed to be vendor-neutral, making it accessible to professionals from diverse backgrounds and experiences. More details

On the other hand, the AWS Certified Machine Learning Engineer – Associate certification is designed for individuals with at least one year of experience building, deploying, and maintaining AI and ML solutions on AWS. This certification validates an individual's skills in developing, deploying, maintaining, and monitoring AI, ML, and generative AI solutions. More details

Purpose and Significance

Introducing these certifications is a significant step forward in the AI and ML landscape. With the increasing demand for AI and ML skills, these certifications aim to bridge the gap between the supply and demand of skilled professionals. By earning these certifications, professionals can demonstrate their expertise and enhance their career prospects, leading to higher salaries and better job opportunities.

According to a study commissioned by AWS, organizations are willing to pay a premium for professionals with AI skills. For instance, IT professionals with AI skills can expect a 47% higher salary, while those in sales and marketing can expect a 43% higher salary. Similarly, professionals in finance can expect a 42% higher salary, and those in business operations can expect a 41% higher salary.

Preparation and Exam Details

To prepare for these certifications, AWS offers a range of training resources, including free foundational cloud courses and AI foundational training. The AWS Certified AI Practitioner beta exam will be available to schedule starting August 13, 2024, and the exam duration is 120 minutes with 85 questions. The exam format includes multiple-choice and multiple-response questions, and the cost is $75 USD.

Comparison with Other Certifications

The AWS Certified AI Practitioner certification is distinct from other certifications in the AI and ML space. For instance, the Certified Artificial Intelligence Practitioner (CAIP) certification offered by CertNexus focuses on vendor-neutral, cross-industry knowledge of AI concepts and skills. While both certifications validate AI and ML knowledge, the AWS certification focuses on AWS-specific technologies and use cases.

The introduction of the AWS Certified AI Practitioner and AWS Certified Machine Learning Engineer – Associate certifications marks a significant milestone in the AI and ML landscape. These certifications offer professionals a unique opportunity to enhance their skills, demonstrate their expertise, and boost their career prospects. With the increasing demand for AI and ML skills, these certifications are poised to play a crucial role in shaping the future of the industry.

Important Use Cases of Amazon EC2

Ashwin Raiyani — Sat, 30 Dec 2023 09:04:19 +0000

Amazon Elastic Compute Cloud (EC2) is a versatile and powerful cloud computing service that finds application across various domains. Here are five of its most impactful use cases:

1. Web Hosting:

EC2 is instrumental for deploying web applications and websites on a large scale.
Its key strength lies in robust scaling capabilities, allowing organizations to adjust capacity within minutes dynamically.
Compared to traditional hosting services, EC2 offers flexibility and efficiency.

2. Big Data Analysis:

EC2 supports the execution of big data analytics applications, requiring high processing power and storage.
It seamlessly integrates with popular distributed computing tools like Hadoop and Spark, enabling effective management and processing of large datasets.

3. High-Performance Computing (HPC):

Tailored for use cases demanding extensive computational capabilities, such as fluid dynamics, financial modeling, or genomic research.
EC2 provides a spectrum of instance types optimized for high-performance computing tasks.
This optimization results in accelerated processing, translating to quicker results.

4. Batch Processing:

EC2 instances are well-suited for running batch jobs, making them ideal for scenarios involving the processing of large volumes of data.
Businesses engaged in image or video processing benefit from the scalability of EC2 instances, ensuring efficient and swift job completion.

5. Backup and Disaster Recovery:

EC2 is a reliable solution for backup and disaster recovery purposes. In case of a disaster, businesses can quickly set up EC2 instances in different regions or availability zones. This approach ensures that applications continue to function, minimizing both downtime and data loss. Amazon EC2 is a versatile cloud computing solution that offers a comprehensive set of features to meet the needs of modern businesses. Whether it's scaling web applications, processing extensive datasets, facilitating high-performance computing, managing batch jobs, or ensuring robust disaster recovery, EC2 is a pillar of reliability in cloud computing.

AWS S3 Cross Region Replication: A Comprehensive

Ashwin Raiyani — Fri, 22 Dec 2023 04:25:39 +0000

AWS S3 Cross Region Replication (CRR) is a feature that allows you to automatically replicate data from one S3 bucket in one AWS region to another S3 bucket in a different region. This is a great way to ensure that your data is always available, even if there is a disruption in one region.

Why use CRR? ☂️

CRR has a number of benefits, including:

Disaster recovery: CRR can help you protect your data from natural disasters or other events that could disrupt one region.
Compliance: Some businesses must store data in multiple regions for compliance reasons. CRR can help you to meet these requirements.
Performance: CRR can improve performance for users in different regions by reducing latency.
How to set up CRR 🛠️

To set up CRR, you will need to:

Create a source bucket and a destination bucket in different regions.
Enable versioning on both buckets.
Create a replication rule in the source bucket.
AWS S3 Cross Region Replication: A guide with emojis 🌎

Why use CRR? ☂️

CRR has a number of benefits, including:

Disaster recovery: CRR can help you to protect your data from natural disasters or other events that could disrupt one region.
Compliance: Some businesses are required to store data in multiple regions for compliance reasons. CRR can help you to meet these requirements.
Performance: CRR can improve performance for users in different regions by reducing latency.
How to set up CRR 🛠️

To set up CRR, you will need to:

Create a source bucket and a destination bucket in different regions.
Enable versioning on both buckets.
Create a replication rule in the source bucket.
Here is a step-by-step guide with emojis:

Step 1: Create a source bucket and a destination bucket in different regions. 🌎 Enable versioning on both buckets. ☂️

Source Bucket

With enabling Bucket Versioning

Destination Bucket — 2

Enabling Versioning — Bucket 2
Step 2: Click on the Management tab of the source bucket and select Replication. ⚙️

Bucket-1 — Goto Management Tab
Click on the Create Replication Rule button. 🆕

Give Rule Name

Select Source Bucket — Select Apply to all objects
Next Step, Select the destination bucket from the list of buckets. 🪣

Select Destination Bucket-2
Next➡️, Scroll down and Create IAM Role,

Create new role
Next click on Save button to create rule. New screen will appear on your screen.

Select No and Click on the Submit button.
Review the settings and click on the Create Rule button. ✅

New Replication Rule created for Bucket 1
The last step is to test whether the rule created is properly working as desired or not. Let's upload one object in Bucket-1 and check whether it will get a replica in bucket-2 or not.

Bucket -1 — uploaded one image file
After a few seconds, you can see same file available in bucket -2 as well.

Conclusion
Here I had implemented AWS S3's Cross-Region Replication in-depth. This involved replicating objects from a source bucket in the North Virginia (us-east-1) region to a destination bucket in the Ohio (us-east-2) region. The replication process was set up to mirror the latest version of content from North Virginia, thus providing an updated representation of the static website in Ohio. By utilizing the features of S3's Cross-Region Replication, here established a reliable and consistent content delivery mechanism across different regions.

Streamline Email Sending with AWS SES, Lambda, and S3 Integration

Ashwin Raiyani — Fri, 22 Dec 2023 04:19:46 +0000

In today's digital world, email remains a vital communication channel for businesses. To simplify the process of sending bulk emails, AWS provides a powerful combination of services: Simple Email Service (SES), Lambda, and Simple Storage Service (S3). In this blog post, we will explore how to integrate these services to efficiently send emails by uploading recipient lists to S3. This streamlined approach saves time, enhances scalability, and offers greater flexibility for email campaigns.

Setting up the Integration:

Creating an AWS SES Configuration:

Activate the SES service in your AWS account.
Verify your domain or email addresses to establish sender identity.
Configure email and customizations based on your requirements.
Setting Up an S3 Bucket:
Create an S3 bucket to store the recipient lists.
Configure appropriate access permissions to ensure secure and controlled data handling.

Developing an AWS Lambda Function:

Create a Lambda function that triggers upon a file upload event in the S3 bucket.
Implement the necessary code to extract recipient information from the uploaded file.

Designing the Workflow:

Define the logic to process each recipient in the uploaded list.
Personalize email content by dynamically populating recipient-specific information.
Leverage Lambda's scalability to handle large recipient lists efficiently.

Streamline Email Sending with AWS SES, Lambda, and S3 Integration

Ashwin Raiyani — Sat, 01 Jul 2023 10:04:42 +0000

Setting up the Integration:

Creating an AWS SES Configuration:

Activate the SES service in your AWS account.
Verify your domain or email addresses to establish sender identity.
Configure email and customizations based on your requirements.
Setting Up an S3 Bucket:
Create an S3 bucket to store the recipient lists.
Configure appropriate access permissions to ensure secure and controlled data handling.

Developing an AWS Lambda Function:

Create a Lambda function that triggers upon a file upload event in the S3 bucket.
Implement the necessary code to extract recipient information from the uploaded file.

Designing the Workflow:

Define the logic to process each recipient in the uploaded list.
Personalize email content by dynamically populating recipient-specific information.
Leverage Lambda's scalability to handle large recipient lists efficiently.

Lead an AWS Cloud Club

Ashwin Raiyani — Tue, 07 Feb 2023 05:34:46 +0000

It’s time! Students, you’ve been waiting, and we are proud to announce that AWS Cloud Clubs, student-led user groups for ages 18+, are opening in 10 regions worldwide. Apply to become your school’s Cloud Club Captain to build community, learn AWS tech, & build your career. Apply here: https://s12d.com/students

🎉 AWS Cloud Clubs are launching now 🎉

Are you:
📚 Enrolled in a College or University or learning on your own
🦉Aged between 18–28
🫶Interested in creating peer-to-peer learning experiences for your local student community
✨Curious about skilling up in AWS technology
👀Looking to build your career and network

If so, please join an AWS Cloud Club near you. We are looking for stellar Cloud Club Captains to lead these clubs in Australia, Bangladesh, France, India, Ireland, Mexico, Nigeria, Pakistan, United Kingdom, and the United States.

What’s in it for you and your communities? Based on your activities, earn perks such as AWS credits, certification vouchers, swag, bespoke learning and networking experiences, and more. We will work with you to make your Club awesome!

Ready? Set? Go! Please fill in the AWS Cloud Club Captain Application Form at https://s12d.com/students. This form is opening now and will close on Feb 19th. If your region isn’t included in the launch list, please fill in the Cloud Clubs interest list to express your interest in founding or joining a future club.

source : https://aws.amazon.com/developer/community/students/

Step 2:Converting .pem to .ppk on Windows

Ashwin Raiyani — Wed, 11 Jan 2023 19:20:31 +0000

If you don’t already have PuTTYGen and PuTTY already installed navigate to:

PuttyGen

https://www.puttygen.com/#Download_PuTTYgen_on_Windows (Links to an external site.)Links to an external site.

PuTTY

https://www.puttygen.com/download-putty#PuTTY_for_windows (Links to an external site.)Links to an external site.

After installation, review the PuTTYGen and PuTTY instructions for this activity:

Converting .pem to .ppk on Windows

Click on Start menu> All Programs > PuTTY > PuTTYgen.

puttygen-window
puttygen-window
The following window will present with options on the crucial a user wants to generate. Select the option ‘RSA (Rivest–Shamir–Adleman). RSA is a public-key cryptosystem that is commonly used to transmit data securely. Users with an older version of PuTTY should select the option – ‘SSH-2 RSA.’

Load .PEM file to puttygen
Load .PEM file to puttygen
Next, click on the option ‘Load.’ As PuTTY supports its native file format, it will only show files that have .ppk file extension. Therefore, users have to choose the ‘All Files’ option from the drop-down bar. It will display all key files included the .pem file.

save private key
save private key
Now, select the .pem file that you want to convert. As aforementioned that PuTTYgen is used for SSH connectivity, so it crucial for users to select the specific file that they plan to convert and click ‘Open.’ To confirm, click on ‘OK.’
In the resultant window, click on ‘Save private key’ which will convert and save the key file in PuTTY compatible format.
PuTTYgen will prompt a warning of saving the key without a passphrase. Hit ‘Yes’ on it.

save private key
save private key
Now, give the name to your file and PuTTYgen will automatically add .ppk file extension.

Launch Amazon EC2 Linux Instance Step 1: Launch a Linux Virtual Machine

Ashwin Raiyani — Wed, 11 Jan 2023 18:53:28 +0000

Step 1: Launch a Linux Virtual Machine

Launch an Amazon EC2 instance

Our first requirement is that our product team would like a Linux web server that has Apache installed on it. They would also like for it to be publicly accessible, so let’s get going.

1.In the AWS Management Console, find and select the Amazon EC2 dashboard

2.From the Amazon EC2 dashboard, click "Launch Instance"

3.Notice the variety of AMIs located on the AMI page. These are different templates for different types of machines. Select the Amazon Linux 2 AMI (HVM)

4.Notice the variety of instance types available. Select the t2.micro instance.

5.Select Next: Configure Instance Details

We are going to use our default Amazon VPC and launch our Amazon EC2 instance into the default public subnet where it will automatically assign our virtual machine a public IP address.

6.Accept the default settings for the Step 3: Configure Instance Details page

7.Click Next: Add Storage

a.We will not need another Amazon Elastic Block Store (Amazon EBS) volume

8.Click Next: Add Tags

9.Click Add tag then configure:

Key: Name Value: WebServer
10.Click Next: Configure Security Group

11.Configure a new security group as follows:

a.Security group name: WebserverSG

b.Description: Security group for my webserver

A security group works very much the same way as a firewall. It contains a set of rules that filter traffic coming into and out of an Amazon EC2 instance. By default, all non-local traffic is blocked. For example, webservers typically allow public traffic access on port 80 (HTTP) and/or port 443 (HTTPS) and also keep SSH rules. In all 3 rule, keep the IP source as "Anywhere"

c.Click Review and Launch.

12.Review the details, scroll down and click Launch.

13.In the Select an existing key pair or create a new key pair dialog box, choose Create a new key pair, enter a name for the key pair, and then choose Download Key Pair. This is the only chance for you to save the private key file, so be sure to download it. Save the private key file in a safe place.

14.On the Launch Status page, scroll to the bottom and click View Instances. You’ll be taken to the Instances page.

AWS EC2 Instance Features:

Ashwin Raiyani — Wed, 11 Jan 2023 09:21:30 +0000

Amazon EC2 instances provide a number of additional features to help you deploy, manage, and scale your applications.

➢ Burstable Performance instances
➢ Multiple Storage Options
➢ EBS Optimized Instances
➢ Cluster Networking

Burstable Performance Instances:
Amazon EC2 allows you to choose between Fixed Performance
Instances (e.g. M5, C5, and R5) and Burstable Performance Instances (e.g. T3). Burstable Performance Instances provide a baseline level of CPU performance with the ability to burst above the baseline.

For example, a t2.small instance receives credits continuously at a rate of 12 CPU Credits per hour. This capability provides baseline performance equivalent to 20% of a CPU core (20% x 60 mins = 12 mins). If the instance does not use the credits it receives, they are stored in its CPU Credit balance up to a maximum of 288 CPU Credits. When the t2.small instance needs to burst to more than 20% of a core, it draws from its CPU Credit balance to handle this surge automatically.

Multiple Storage Options: Amazon EC2 allows you to choose between multiple storage options based on your requirements. Amazon EBS is a durable, block-level storage volume that you can attach to a
single, running Amazon EC2 instance. Amazon EBS provides three volume types to best meet the needs of your workloads: General Purpose (SSD), Provisioned IOPS (SSD), and Magnetic.5

EBS Optimized instances: For an additional, low, hourly fee, customers can launch selected Amazon EC2 instances types as EBS-optimized instances. For M6g, M5, M4, C6g, C5, C4, R6g, P3, P2, G3, and D2 instances, this feature is enabled by default at no additional cost. EBS-optimized instances enable EC2 instances to fully use the IOPS provisioned on an EBS volume. EBS-optimized instances deliver dedicated throughput between Amazon EC2 and Amazon EBS, with options between 500 and 4,000 Megabits per second (Mbps) depending on the instance type used.

Cluster Networking: Select EC2 instances support cluster networking when launched into a common cluster placement group. A cluster placement group provides low-latency networking between all instances in the cluster. The bandwidth an EC2 instance can utilize depends on the instance type and its networking performance specification.

DEV Community: Ashwin Raiyani

AI That Writes vs AI That Acts: Understanding Generative and Agentic Intelligence

Table of Contents

Generative AI: The Creative Genius

Examples you've probably already used:

Key Characteristics:

Agentic AI: The Autonomous Doer

Examples that are changing the game:

Key Characteristics:

The Big Comparison Table

⚙️ How They Work Under the Hood

Generative AI — The Architecture

Agentic AI — The Architecture

🌍 Real-World Use Cases

Generative AI Shines When...

Agentic AI Shines When...

Mini Walkthrough: See Them in Action

Scenario: "The login button isn't working on mobile" 🐛📱

With Generative AI (e.g., ChatGPT):

With Agentic AI (e.g., GitHub Copilot Coding Agent):

Two Paradigms of AI: Generative and Agentic: Can They Work Together?

Where is This All Heading?

💡 Pro Tips for Beginners

Tip #1: Start With Generative, Graduate to Agentic

Tip #2: "Agentic" Doesn't Mean "No Humans"

Tip #3: Learn the Tooling Ecosystem

Tip #4: Watch for the "Agent Tax"

Tip #5: Build Your First Agent This Weekend

Quick Reference Cheat Sheet

🏁 Wrapping Up

Call to Action

Anomalies to Insights: CloudWatch & SageMaker for Smarter Observability

Table of Contents

The 3 AM Model Meltdown Scenario

🎯 What You'll learn Today

Why Traditional Monitoring Falls Short

📉 The Silent Killer: Model Drift

⚡ The ML Monitoring Gap

CloudWatch Fundamentals: Your ML Observatory

Core Components for ML Monitoring

Setting Up Your First ML Metric

💡 Pro Tip: Namespace Organization

Understanding CloudWatch Costs for ML

💰 Cost Optimization Strategy

SageMaker's Observability Superpowers

SageMaker Model Monitor: The Game Changer

Setting Up Data Quality Monitoring

🎯 Baseline Best Practices

Understanding SageMaker's Detection Algorithms

Hands-On: Building Your Complete Observability Pipeline

Step-by-Step Implementation

Step 1: Deploy Your Model with Monitoring Enabled

Step 2: Create Custom CloudWatch Metrics

Step 3: Configure SageMaker Model Monitor

Step 4: Set Up Intelligent Alerts

🚀 Implementation Tips

Real-World Success Story: E-commerce Recommendation Recovery

🛍️ The Challenge

The Investigation Process

1. Automatic Drift Detection

2. Business Impact Correlation

3. Automated Alert and Response

📈 The Results

Key Lessons Learned

Best Practices & Advanced Optimization

Cost Optimization Strategies

Alert Fatigue Prevention

Advanced Integration Patterns

Team Workflow Integration

🎯 Recommended Team Responsibilities

🚀 Ready to Transform Your ML Observability?

Your Next Steps:

🎓 Additional Learning Resources

# 🚀 Demystifying AWS: A Hands-On Journey Through Cloud Economics and Global Infrastructure 🌍💡

📘 Why It Mattered

💸 Session 1: Understanding Cloud Costs with Analogies

🔍 Hands-On Demo: AWS Pricing Calculator & Budgets

🌐 Session 2: Exploring AWS Global Infrastructure

🧭 Hands-On Demo: Global Map & Latency Testing

✅ What Students Took Away