Forem: dineshrajdhanapathyDD

Building an Agentic AI Weather Assistant Using Amazon Bedrock

dineshrajdhanapathyDD — Mon, 02 Mar 2026 13:40:36 +0000

Agentic AI weather assistant built with Amazon Bedrock that plans API calls, fetches real-time weather data, and delivers human-readable forecasts

In the evolving landscape of artificial intelligence, the shift from traditional “smart encyclopedias” to Agentic AI represents a significant leap in capability. While traditional AI systems provide static responses based on training data, agentic systems are designed to think, plan, and act to solve complex problems. This article explores the core building blocks of Agentic AI, using a hands-on weather assistant project built with Amazon Bedrock and Python as a primary example.

Understanding Agentic AI

Agentic AI moves beyond the “Question → Answer” model toward a “Problem → Plan → Action → Result” workflow. According to the sources, true agentic systems are defined by three key characteristics:

Autonomy: The ability to make independent decisions, such as choosing appropriate tools or interpreting location descriptions without constant human guidance.
Reactivity: The capacity to respond to environmental changes, handle errors, and adjust strategies based on real-time results.
Proactivity: Taking the initiative to achieve goals through multi-step planning and anticipating user needs

The Architecture of an AI Agent

A functional AI agent requires a “brain” for reasoning and “hands” to interact with the world. The sources outline a four-step process for a weather-focused agent:

User Input: The user provides a location in any format (e.g., ZIP code, city name, or coordinates).
AI Planning: Using a model like Claude 4.5 Sonnet , the agent analyzes the input and determines the necessary coordinates and API endpoints.
Action (API Calls): The agent executes the plan. For weather data, this involves a two-step process: first calling the NWS Points API to find the correct forecast office, then calling the Forecast API for the actual data.
AI Summary: The agent processes technical JSON data into a human-friendly, readable summary

Why Amazon Bedrock?

Amazon Bedrock serves as a foundation for these systems by providing access to high-performing models like Claude, which excels at complex reasoning and structured data processing. Bedrock offers managed infrastructure and enterprise-grade security , allowing developers to build agents that are both scalable and cost-effective.

Real-World Impact and Future Steps

The patterns used to build a weather assistant are highly transferable to other industries:

Travel and Logistics: Agents can check weather, monitor traffic, and automatically adjust itineraries or routes.
Agriculture: Monitoring environmental conditions to recommend specific farming actions.
Emergency Management: Tracking severe weather to coordinate rapid responses.
Business Operations: Automating market analysis, customer support, and risk assessment.

Development and Implementation

Building an agent can be approached through different interfaces depending on the end-user:

Command-Line Interface (CLI): Ideal for developers and automation, focusing on direct interaction and raw workflow steps.
Web Application: Using tools like Streamlit, developers can create interactive experiences that visualize the agent’s “thinking” phases, such as planning, execution, and analysis.

The sources emphasize that building from scratch using pure Python and the AWS SDK (boto3) without complex framework abstractions allows developers to truly understand the “aha moment” of how an AI agent functions.

Environment Setup

🏠 Your Own AWS Account

To set up the development environment for the weather agent in your own AWS account , you will need to follow a series of steps to configure your local machine and AWS permissions. This process typically takes about 12 minutes.

Prerequisites

Before starting, ensure you have the following:

Python 3.7+ installed locally.
An AWS account with appropriate administrative or developer permissions.
The AWS CLI installed on your machine.

Step 1: Development Environment and Python

You should use a code editor that supports Python syntax, such as Visual Studio Code or PyCharm. Once your editor is ready, verify your Python installation in the terminal using python --version. On macOS, you may specifically need to use python3 and pip3.

Step 2: AWS Credential Configuration

You must provide your agent with access to AWS services using one of two methods

AWS CLI (Recommended): Run aws configure In your terminal, enter your Access Key ID, Secret Access Key , and set the default region to us-west-2.
Environment Variables: Manually export AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, and AWS_DEFAULT_REGION in your terminal session.

Step 3: Enable Claude 4.5 Sonnet in Amazon Bedrock

This is a critical step ; without it, your agent will not function.

Log into the Amazon Bedrock console.
Ensure you are in the us-west-2 (Oregon) region.
Navigate to Model Access and request access for Claude 4.5 Sonnet.
Ensure your IAM user has the permissions bedrock:InvokeModel, bedrock:Converse, and bedrock:ListFoundationModels

Step 4: Project Setup and Dependencies

Create a dedicated workspace for your agent and set up a virtual environment to manage packages:

Create a directory: mkdir agentic-ai-workshop && cd agentic-ai-workshop.
Initialize a Virtual Environment: Run python -m venv .venv and activate it. You should see (.venv) it in your terminal prompt once active.
Install Packages: Create a requirements.txt file (or install directly) containing the necessary libraries like boto3 , requests , and streamlit

Step 5: Verification

To confirm everything is configured correctly, run aws sts get-caller-identity it in your terminal. This should return your AWS account details without errors. Once verified, you are ready to begin building the agent logic using boto3 to interface with the model python -c "import boto3, streamlit, requests; print('✅ All packages installed')"

Troubleshooting Common Issues

“AWS credentials not found” : Run aws configure to enter your credentials or set the required environment variables manually.
“Model access denied” : You must specifically request access for Claude 4.5 Sonnet in the Amazon Bedrock console and ensure you are working in the us-west-2 (Oregon) region.
“Permission denied” errors : Verify that your IAM user has the minimum required permissions: bedrock:InvokeModel, bedrock:Converse, and bedrock:ListFoundationModels.
“Python command not found” : Ensure Python is installed and added to your system PATH; on some systems, you may need to use python3 and pip3 instead of python and pip.
Virtual environment issues : If you encounter execution errors, ensure your virtual environment is active (indicated by (.venv) in your terminal prompt).
Package installation fails : Try re-running the installation command for your dependencies in the terminal.
Invalid or international locations : The National Weather Service API used by the agent only covers US locations ; international cities or misspellings may result in failed data retrieval.
Network and connectivity issues : The agent may encounter timeouts or connection problems, which require robust error handling or retry logic.
Data processing errors : The agent must be able to handle unexpected, incomplete, or inconsistent JSON data returned from the weather APIs.

Understanding Our Agent Architecture

How the National Weather Service APIs Work

The National Weather Service (NWS) provides free weather data through a mandatory two-step API process because the US is divided into a grid system where different forecast offices cover specific squares.

Points API : This is the first step (https://api.weather.gov/points/{lat},{lon}). It takes latitude and longitude coordinates as input and identifies which NWS forecast office covers that specific location, along with the necessary grid coordinates. For example, coordinates for Seattle map to the "SEW" office at grid 124,67.
Forecast API : This is the second step (https://api.weather.gov/gridpoints/{office}/{gridX},{gridY}/forecast). It uses the specific office and grid data obtained from the Points API to retrieve the detailed weather forecast in a technical JSON format.

How Our Weather Agent Works

The weather assistant functions as a reasoning engine that follows a linear path: User Input → AI Planning → API Calls → AI Summary → Response.

Instead of hardcoding every possible location, the agent uses Claude 4.5 Sonnet to dynamically figure out what coordinates and API calls are needed based on what the user types.

Understanding the Flow.

The flow of the agent is designed to bridge the gap between human language and technical data:

Analyze : The AI (Claude) interprets the user’s location description.
Determine : It identifies the required coordinates and API endpoints.
Execute : Two sequential API calls are made — first to get the office info, then the weather data.
Translate : The AI processes the resulting raw data into a friendly summary for the user.

The 4 Steps in Detail

Step 1: User Input

📝The agent is designed to be highly flexible, accepting various location formats without requiring a specific structure. Users can enter:

City names (e.g., “Seattle” or “Seattle, WA”).
ZIP codes (e.g., “90210”).
Informal descriptions (e.g., “downtown Portland”).
Coordinates (e.g., “47.6062, -122.3321”).

Step 2: AI Planning

🧠In this phase, Claude 4.5 Sonnet acts as the “brain.” It analyzes the input to create a technical strategy:

It determines the precise coordinates for the user’s location.
It identifies the correct NWS API endpoints.
It plans the sequence of calls (knowing it must hit the Points API before the Forecast API).

Step 3: API Calls

🔗The agent executes the plan by making two distinct requests:

Points API Call : It sends the coordinates to get the forecast office and grid info.
Forecast API Call : It uses the URL returned by the first call to fetch the actual, detailed weather data.

Step 4: AI Summary

📊The final step involves converting the raw JSON data (which is complex and technical) into a human-friendly format. Claude filters through the technical details to provide a natural response, such as: “Today: Partly cloudy with a high of 72°F. Wind: West at 5–10 mph”

Building the Command-Line Agent

Constructing a command-line interface (CLI) agent allows you to experience the “aha moment” of agentic AI by building every component from scratch. This approach is ideal for developers because it provides a direct, focused interaction and clearly displays the raw workflow steps

Step 1: Establishing the Amazon Bedrock Connection

The foundation of the agent is its connection to the “brain” Claude 4.5 Sonnet

Implementation: Create a file named weather_agent_cli.py within your agentic-ai-workshop directory

# Import necessary libraries
import boto3 # AWS SDK for Python - allows us to interact with AWS services
import json # For handling JSON data
import subprocess # For running system commands like curl
import time # For adding delays and timing operations
from datetime import datetime # For timestamps and date operations

def call_claude_sonnet(prompt):
    """
    This function sends a prompt to Claude 4.5 Sonnet and gets a response.
    This is the "brain" of our agent - where the AI thinking happens.

    Args:
        prompt (str): The question or instruction we want to send to Claude

    Returns:
        tuple: (success: bool, response: str) - success status and Claude's response or error message
    """
    # Create a connection to Amazon Bedrock service
    # Bedrock is AWS's service for accessing AI models like Claude
    bedrock = boto3.client(
        service_name='bedrock-runtime', # Specify we want the runtime version for making AI calls
        region_name='us-west-2' # AWS region - using us-west-2 as specified
    )

    try:
        # Send our prompt to Claude and get a response
        response = bedrock.converse(
            # Specify which version of Claude we want to use
            modelId='us.anthropic.claude-sonnet-4-5-20250929-v1:0', # Claude 4.5 Sonnet

            # Format our message - Claude expects messages in a specific structure
            messages=[
                {
                    "role": "user", # We are the user asking a question
                    "content": [{"text": prompt}] # Our actual question/prompt
                }
            ],

            # Configure how Claude should respond
            inferenceConfig={
                "maxTokens": 2000, # Maximum length of response (tokens ≈ words)
                "temperature": 0.7 # Creativity level (0=very focused, 1=very creative)
            }
        )

        # Extract the actual text response from Claude's response structure
        # The response comes nested in a complex structure, so we dig down to get the text
        return True, response['output']['message']['content'][0]['text']

    except Exception as e:
        # If something goes wrong, return an error message
        return False, f"Error calling Claude: {str(e)}"

def execute_curl_command(url):
    """
    Execute a curl command to fetch data from an API.
    This is how our agent "acts" in the real world - making HTTP requests.

    Args:
        url (str): The URL to fetch data from

    Returns:
        tuple: (success: bool, response: str) - success status and API response or error message
    """
    try:
        # Use curl command to make HTTP request
        # curl is a command-line tool for making HTTP requests
        result = subprocess.run(
            ['curl', '-s', url], # -s flag makes curl silent (no progress info)
            capture_output=True, # Capture the output so we can process it
            text=True, # Return output as text (not bytes)
            timeout=30 # Give up after 30 seconds
        )

        # Check if the command was successful
        if result.returncode == 0:
            return True, result.stdout
        else:
            return False, f"Curl command failed: {result.stderr}"

    except subprocess.TimeoutExpired:
        return False, "Request timed out after 30 seconds"
    except Exception as e:
        return False, f"Error executing curl: {str(e)}"

def generate_weather_api_calls(location):
    """
    Use Claude to intelligently generate National Weather Service API calls for a given location.
    This is where the "agentic" magic happens - AI generating the API call URL.

    Args:
        location (str): The location provided by the user

    Returns:
        tuple: (success: bool, api_calls: list) - success status and list of API URLs or error message
    """
    # Create a detailed prompt that teaches Claude how to generate NWS API calls
    prompt = f"""
You are an expert at working with the National Weather Service (NWS) API.

Your task: Generate the NWS API URL to get weather forecast data for "{location}".

Instructions:
1. First, determine the approximate latitude and longitude coordinates for this location
2. Generate the NWS Points API URL: https://api.weather.gov/points/{{lat}},{{lon}}

For the coordinates, use your knowledge to estimate:
- Major cities: Use well-known coordinates
- ZIP codes: Estimate based on the area
- States: Use approximate center coordinates
- In case a location description is provided instead of a location name, please use the most likely city and state name as the location for the coordinates

Example for Seattle:
https://api.weather.gov/points/47.6062,-122.3321

Example for largest city in USA:
Based on your knowledge, you will establish location is New York City
https://api.weather.gov/points/40.7128,-74.0060

Now generate the API call (Points API) for the established location. 
Return ONLY the complete Points API URL, nothing else.
Format: https://api.weather.gov/points/LAT,LON
"""

    print(f"🧠 AI is analyzing '{location}' and generating weather API calls...")
    success, response = call_claude_sonnet(prompt)

    if success:
        # Clean up the response - sometimes Claude adds extra text
        api_url = response.strip()
        # Make sure we got a valid URL
        if api_url.startswith('https://api.weather.gov/points/'):
            return True, [api_url] # Return as list for consistency
        else:
            return False, f"AI generated invalid URL: {api_url}"
    else:
        return False, response

def get_forecast_url_from_points_response(points_json):
    """
    Extract the forecast URL from the NWS Points API response.

    Args:
        points_json (str): JSON response from the Points API

    Returns:
        tuple: (success: bool, forecast_url: str) - success status and forecast URL or error message
    """
    try:
        data = json.loads(points_json)
        forecast_url = data['properties']['forecast']
        return True, forecast_url
    except (json.JSONDecodeError, KeyError) as e:
        return False, f"Error parsing Points API response: {str(e)}"

def process_weather_response(raw_json, location):
    """
    Use Claude to convert raw NWS API JSON into a human-readable weather summary.
    This is where AI processes complex data into useful information.

    Args:
        raw_json (str): Raw JSON response from NWS API
        location (str): Original location for context

    Returns:
        tuple: (success: bool, summary: str) - success status and processed summary or error message
    """
    prompt = f"""
You are a weather information specialist. I have raw National Weather Service forecast data for "{location}" that needs to be converted into a clear, helpful summary for a general audience.

Raw NWS API Response:
{raw_json}

Please create a weather summary that includes:
1. A brief introduction with the location
2. Current conditions and today's forecast
3. The next 2-3 days outlook with key details (temperature, precipitation, wind)
4. Any notable weather patterns or alerts
5. Format the response to be easy to read and understand

Make it informative and practical for someone planning their activities. Focus on being helpful and clear.
"""

    print(f"📊 AI is processing weather data and creating summary...")
    success, response = call_claude_sonnet(prompt)

    return success, response

def run_weather_agent():
    """
    Main function that orchestrates our AI agent.
    This demonstrates the complete agentic workflow.
    """
    print("🌤️ Welcome to the Weather AI Agent!")
    print("This agent uses Claude 4.5 Sonnet to help you get weather forecasts.")
    print("=" * 60)

    while True:
        # Get user input
        location = input("\n🔍 Enter a location name or description (or 'quit' to exit): ").strip()

        if location.lower() in ['quit', 'exit', 'q']:
            print("👋 Thanks for using the Weather Agent!")
            break

        if not location:
            print("❌ Please enter a location name or description.")
            continue

        print(f"\n🚀 Starting weather analysis for '{location}'...")
        print("-" * 40)

        # Step 1: AI generates the Points API URL
        print("Step 1: 🧠 AI Planning Phase")
        success, api_calls = generate_weather_api_calls(location)

        if not success:
            print(f"❌ Failed to generate API calls: {api_calls}")
            continue

        points_url = api_calls[0]
        print(f"✅ Generated Points API URL: {points_url}")

        # Step 2: Execute the Points API call
        print("\nStep 2: 🔗 Points API Execution")
        print("Fetching location data from National Weather Service...")
        success, points_response = execute_curl_command(points_url)

        if not success:
            print(f"❌ Failed to fetch points data: {points_response}")
            continue

        print(f"✅ Received points data")

        # Step 3: Extract forecast URL from Points response
        print("\nStep 3: 📍 Extracting Forecast URL")
        success, forecast_url = get_forecast_url_from_points_response(points_response)

        if not success:
            print(f"❌ Failed to extract forecast URL: {forecast_url}")
            continue

        print(f"✅ Forecast URL: {forecast_url[:60]}...")

        # Step 4: Execute the Forecast API call
        print("\nStep 4: 🌦️ Forecast API Execution")
        print("Fetching weather forecast data...")
        success, forecast_response = execute_curl_command(forecast_url)

        if not success:
            print(f"❌ Failed to fetch forecast data: {forecast_response}")
            continue

        print(f"✅ Received {len(forecast_response)} characters of forecast data")

        # Step 5: AI processes the response
        print("\nStep 5: 📊 AI Analysis Phase")
        success, summary = process_weather_response(forecast_response, location)

        if not success:
            print(f"❌ Failed to process data: {summary}")
            continue

        # Step 6: Display results
        print("\nStep 6: 💬 Weather Forecast")
        print("=" * 60)
        print(summary)
        print("=" * 60)

        print(f"\n✅ Weather analysis complete for '{location}'!")

# Run the agent when the script is executed
if __name__ == " __main__":
    run_weather_agent()

Key Components : The code establishes a Bedrock Client in the us-west-2 region and structures prompts in the specific message format Claude expects
Configuration : You must set inference parameters to control the agent’s response length and creativity , while implementing error handling to catch connection issues

Step 2: Developing the Agent’s Logic

An agent needs both “hands” to act and a “brain” to plan. This is achieved through four primary functions.

execute_curl_command(): Functions as the agent’s hands , executing the actual HTTP requests to external APIs

generate_weather_api_calls(): Acts as the planning brain , determining the correct coordinates and API endpoints based on user input

get_forecast_url_from_points_response(): A utility function to extract the specific forecast URL from the National Weather Service (NWS) JSON response

process_weather_response(): Serves as the analysis brain , translating complex technical data into human-readable insights

Step 3: Executing the Main Workflow

The agent follows a circular pattern that defines the Agentic AI Workflow :

Planning : The AI analyzes the location (e.g., “Seattle” or “90210”) and maps out the necessary API strategy.
Action : The agent executes the planned sequence, calling the Points API first to get office data, followed by the Forecast API.
Processing : Claude analyzes the raw, multi-period JSON weather data to identify the most relevant information.
Response : The final summary is presented to the user in a friendly format, such as: “Today: Partly cloudy with a high of 72°F”

Testing and Validation

Once your script is complete, you can run it from your terminal using python weather_agent_cli.py To see the agent's autonomy and flexibility in action,

Running the Web Application

To run the web application for your weather agent, you will use Streamlit , a Python library that transforms the agentic logic into an interactive, visual experience. While the web version uses the identical agentic AI logic as the command-line version, it provides a professional presentation with real-time progress indicators.

Launching the Application

Inside your agentic-ai-workshop folder, ensure you have created the weather_agent_web.py file with the complete code provided in the workshop.

Copy this complete code:

import streamlit as st
import boto3
import subprocess
import json
import time
from datetime import datetime
from PIL import Image
import os

# Page configuration
st.set_page_config(
    page_title="Weather AI Agent",
    page_icon="🌤️",
    layout="wide",
    initial_sidebar_state="expanded"
)

# Custom CSS for better styling
st.markdown("""
<style>
    .step-container {
        border: 2px solid #e0e0e0;
        border-radius: 10px;
        padding: 20px;
        margin: 10px 0;
        background-color: #f9f9f9;
    }
    .step-header {
        font-size: 18px;
        font-weight: bold;
        color: #1f77b4;
        margin-bottom: 10px;
    }
    .success-box {
        border-left: 5px solid #28a745;
        background-color: #d4edda;
        padding: 10px;
        margin: 10px 0;
        color: #000000;
    }
    .error-box {
        border-left: 5px solid #dc3545;
        background-color: #f8d7da;
        padding: 10px;
        margin: 10px 0;
        color: #000000;
    }
    .info-box {
        border-left: 5px solid #17a2b8;
        background-color: #d1ecf1;
        padding: 10px;
        margin: 10px 0;
        color: #000000;
    }
</style>
""", unsafe_allow_html=True)

def call_claude_sonnet(prompt):
    """
    Connect to Claude 4.5 Sonnet via Amazon Bedrock
    """
    bedrock = boto3.client(
        service_name='bedrock-runtime',
        region_name='us-west-2'
    )

    try:
        response = bedrock.converse(
            modelId='us.anthropic.claude-sonnet-4-5-20250929-v1:0',
            messages=[
                {
                    "role": "user",
                    "content": [{"text": prompt}]
                }
            ],
            inferenceConfig={
                "maxTokens": 2000,
                "temperature": 0.7
            }
        )

        return True, response['output']['message']['content'][0]['text']

    except Exception as e:
        return False, f"Error calling Claude: {str(e)}"

def execute_curl_command(url):
    """
    Execute curl command to fetch API data
    """
    try:
        result = subprocess.run(
            ['curl', '-s', url],
            capture_output=True,
            text=True,
            timeout=30
        )

        if result.returncode == 0:
            return True, result.stdout
        else:
            return False, f"Curl command failed: {result.stderr}"

    except subprocess.TimeoutExpired:
        return False, "Request timed out after 30 seconds"
    except Exception as e:
        return False, f"Error executing curl: {str(e)}"

def generate_weather_api_calls(location):
    """
    Use Claude to generate NWS API calls
    """
    prompt = f"""
You are an expert at working with the National Weather Service (NWS) API.

Your task: Generate the NWS API URL to get weather forecast data for "{location}".

Instructions:
1. First, determine the approximate latitude and longitude coordinates for this location
2. Generate the NWS Points API URL: https://api.weather.gov/points/{{lat}},{{lon}}

For the coordinates, use your knowledge to estimate:
- Major cities: Use well-known coordinates
- ZIP codes: Estimate based on the area
- States: Use approximate center coordinates
- In case a location description is provided instead of a location name, please use the most likely city and state name as the location for the coordinates

Example for Seattle:
https://api.weather.gov/points/47.6062,-122.3321

Example for largest city in USA:
Based on your knowledge, you will establish location is New York City
https://api.weather.gov/points/40.7128,-74.0060

Now generate the API call (Points API) for the established location. 
Return ONLY the complete Points API URL, nothing else.
Format: https://api.weather.gov/points/LAT,LON
"""

    success, response = call_claude_sonnet(prompt)

    if success:
        api_url = response.strip()
        if api_url.startswith('https://api.weather.gov/points/'):
            return True, [api_url]
        else:
            return False, f"AI generated invalid URL: {api_url}"
    else:
        return False, response

def get_forecast_url_from_points_response(points_json):
    """
    Extract forecast URL from Points API response
    """
    try:
        data = json.loads(points_json)
        forecast_url = data['properties']['forecast']
        return True, forecast_url
    except (json.JSONDecodeError, KeyError) as e:
        return False, f"Error parsing Points API response: {str(e)}"

def process_weather_response(raw_json, location):
    """
    Use Claude to process NWS API response
    """
    prompt = f"""
You are a weather information specialist. I have raw National Weather Service forecast data for "{location}" that needs to be converted into a clear, helpful summary for a general audience.

Raw NWS API Response:
{raw_json}

Please create a weather summary that includes:
1. A brief introduction with the location
2. Current conditions and today's forecast
3. The next 2-3 days outlook with key details (temperature, precipitation, wind)
4. Any notable weather patterns or alerts
5. Format the response to be easy to read and understand

Make it informative and practical for someone planning their activities. Focus on being helpful and clear.
"""

    success, response = call_claude_sonnet(prompt)
    return success, response

# Sidebar with information
st.sidebar.title("🤖 About This Agent")
st.sidebar.markdown("""
This AI agent demonstrates **Agentic AI** principles:

**🧠 Intelligence** : Uses Claude 4.5 Sonnet to understand locations and plan API calls

**🔗 Action** : Automatically calls the National Weather Service API

**📊 Processing** : Converts complex weather data into readable forecasts

**💬 Response** : Provides helpful, practical weather information
""")

st.sidebar.markdown("---")
st.sidebar.markdown("### 🏗️ Architecture")
st.sidebar.markdown("""
1. **User Input** → Location name
2. **AI Planning** → Generate API calls
3. **Points API** → Get forecast office  
4. **Forecast API** → Get weather data
5. **AI Processing** → Create summary
6. **Display Results** → Show to user
""")

# Main application
st.title("🌤️ Weather AI Agent")
st.markdown("### Powered by Claude 4.5 Sonnet on Amazon Bedrock")

st.markdown("""
This intelligent agent helps you get weather forecasts using the National Weather Service API. 
Enter any location below and watch the AI agent work through its reasoning process!
""")

# Initialize session state for results
if 'show_results' not in st.session_state:
    st.session_state.show_results = False

# Input section
st.markdown("---")
location = st.text_input(
    "🔍 Enter a location name or description:",
    placeholder="e.g., Seattle, 90210, New York City, National park near Homestead in Florida",
    help="You can enter city names, ZIP codes, state names, or location descriptions"
)

# Create columns for the buttons
button_col1, button_col2 = st.columns([2, 1])

with button_col1:
    get_forecast = st.button("🚀 Get Weather Forecast", type="primary")

with button_col2:
    clear_results = st.button("🗑️ Clear Results", type="secondary")

# Clear results functionality
if clear_results:
    st.session_state.show_results = False
    st.success("🗑️ Results cleared! Enter a new location to get a fresh forecast.")

if get_forecast:
    st.session_state.show_results = True

if st.session_state.show_results and get_forecast:
    if not location:
        st.error("❌ Please enter a location name or description.")
    else:
        # Create columns for better layout
        col1, col2 = st.columns([2, 1])

        with col1:
            st.markdown(f"## Weather Analysis for: **{location}**")

            # Step 1: AI Planning
            with st.container():
                st.markdown('<div class="step-container">', unsafe_allow_html=True)
                st.markdown('<div class="step-header">🧠 Step 1: AI Planning Phase</div>', unsafe_allow_html=True)

                with st.spinner("Claude is analyzing the location and planning the API calls..."):
                    success, api_calls = generate_weather_api_calls(location)

                if success:
                    points_url = api_calls[0]
                    st.markdown('<div class="success-box">✅ Points API URL generated successfully!</div>', unsafe_allow_html=True)
                    st.code(points_url, language="text")
                else:
                    st.markdown(f'<div class="error-box">❌ Failed to generate API calls: {api_calls}</div>', unsafe_allow_html=True)
                    st.stop()

                st.markdown('</div>', unsafe_allow_html=True)

            # Step 2: Points API Execution
            with st.container():
                st.markdown('<div class="step-container">', unsafe_allow_html=True)
                st.markdown('<div class="step-header">🔗 Step 2: Points API Execution</div>', unsafe_allow_html=True)

                with st.spinner("Fetching location data from National Weather Service..."):
                    success, points_response = execute_curl_command(points_url)

                if success:
                    st.markdown('<div class="success-box">✅ Received location data from NWS</div>', unsafe_allow_html=True)

                    # Show a preview of the raw data
                    with st.expander("🔍 View Raw Points API Response (first 500 characters)"):
                        st.code(points_response[:500] + "..." if len(points_response) > 500 else points_response, language="json")
                else:
                    st.markdown(f'<div class="error-box">❌ Failed to fetch points data: {points_response}</div>', unsafe_allow_html=True)
                    st.stop()

                st.markdown('</div>', unsafe_allow_html=True)

            # Step 3: Extract Forecast URL
            with st.container():
                st.markdown('<div class="step-container">', unsafe_allow_html=True)
                st.markdown('<div class="step-header">📍 Step 3: Extracting Forecast URL</div>', unsafe_allow_html=True)

                success, forecast_url = get_forecast_url_from_points_response(points_response)

                if success:
                    st.markdown('<div class="success-box">✅ Forecast URL extracted successfully!</div>', unsafe_allow_html=True)
                    st.code(forecast_url, language="text")
                else:
                    st.markdown(f'<div class="error-box">❌ Failed to extract forecast URL: {forecast_url}</div>', unsafe_allow_html=True)
                    st.stop()

                st.markdown('</div>', unsafe_allow_html=True)

            # Step 4: Forecast API Execution
            with st.container():
                st.markdown('<div class="step-container">', unsafe_allow_html=True)
                st.markdown('<div class="step-header">🌦️ Step 4: Forecast API Execution</div>', unsafe_allow_html=True)

                with st.spinner("Fetching weather forecast data..."):
                    success, forecast_response = execute_curl_command(forecast_url)

                if success:
                    st.markdown(f'<div class="success-box">✅ Received {len(forecast_response):,} characters of forecast data</div>', unsafe_allow_html=True)

                    # Show a preview of the raw data
                    with st.expander("🔍 View Raw Forecast API Response (first 500 characters)"):
                        st.code(forecast_response[:500] + "..." if len(forecast_response) > 500 else forecast_response, language="json")
                else:
                    st.markdown(f'<div class="error-box">❌ Failed to fetch forecast data: {forecast_response}</div>', unsafe_allow_html=True)
                    st.stop()

                st.markdown('</div>', unsafe_allow_html=True)

            # Step 5: AI Processing
            with st.container():
                st.markdown('<div class="step-container">', unsafe_allow_html=True)
                st.markdown('<div class="step-header">📊 Step 5: AI Analysis Phase</div>', unsafe_allow_html=True)

                with st.spinner("Claude is processing the weather data and creating a summary..."):
                    success, summary = process_weather_response(forecast_response, location)

                if success:
                    st.markdown('<div class="success-box">✅ Weather analysis complete!</div>', unsafe_allow_html=True)
                else:
                    st.markdown(f'<div class="error-box">❌ Failed to process data: {summary}</div>', unsafe_allow_html=True)
                    st.stop()

                st.markdown('</div>', unsafe_allow_html=True)

            # Step 6: Results
            st.markdown("---")
            st.markdown("## 🌤️ Weather Forecast")
            st.markdown(summary)

        with col2:
            # Real-time status updates
            st.markdown("### 📊 Process Status")

            status_container = st.container()
            with status_container:
                st.markdown("""
                <div class="info-box">
                <strong>🔄 Agent Workflow:</strong><br>
                ✅ Planning Phase<br>
                ✅ Points API Call<br>
                ✅ URL Extraction<br>
                ✅ Forecast API Call<br>
                ✅ Data Processing<br>
                ✅ Results Generated
                </div>
                """, unsafe_allow_html=True)

            st.markdown("### 🎯 What Makes This Agentic?")
            st.markdown("""
            - **🧠 Reasoning** : AI understands location formats
            - **📋 Planning** : Generates appropriate API call sequences
            - **🔧 Action** : Executes real-world API requests
            - **📊 Processing** : Converts raw data to insights
            - **🔄 Adaptation** : Handles different location types
            """)

# Footer
st.markdown("---")
st.markdown("""
### 🔬 About This Demo

This application demonstrates **Agentic AI** principles using:
- **Amazon Bedrock** with Claude 4.5 Sonnet for intelligent reasoning
- **National Weather Service API** for real-time weather data
- **Streamlit** for interactive web interface

**⚠️ Important** : This uses official NWS data for educational purposes. For critical weather decisions, consult official sources.
""")

# Add some example queries
st.markdown("### 💡 Try These Examples:")
st.markdown("""
**Suggested locations to test:**
- **Seattle** - Major city (tests city name recognition)
- **90210** - ZIP code (tests postal code handling)  
- **New York City** - Multi-word city (tests complex location parsing)
- **Miami, FL** - City with state (tests state abbreviations)
- **Chicago** - Another major city (tests different coordinates)
- **National park near Homestead in Florida** - Location description (tests AI reasoning)
- **Largest City in California** - Descriptive query (tests knowledge-based location finding)

Simply copy any of these into the location input above and click "Get Weather Forecast"!
""")

To start the application, run the following command in your terminal: streamlit run weather\_agent\_web.py

Once executed, you will see output in your terminal indicating the local URL where you can view the interface in your web browser.

You should see output like:

  You can now view your Streamlit app in your browser.

  Local URL: http://localhost:8501
  Network URL: http://192.168.1.100:8501

Interactive Features to Explore

The web interface is designed to make the “agentic” nature of the AI visible to the user through several key features:

Step-by-Step Visualization : Unlike the CLI, the web app allows you to watch each phase of the workflow as it happens, including the AI Planning Phase , API Execution , and AI Analysis.
Raw Data Inspection : You can use expandable sections to view the complex JSON data the agent is processing behind the scenes.
Real-time Status : A sidebar allows you to monitor the agent’s progress as it moves from understanding your request to fetching and summarizing data

Observations and Testing

When running the web application, you should observe how the AI demonstrates Planning Intelligence and Data Processing :

Input Flexibility : Test how it recognizes various inputs like “94129” or “Times Square” and maps them to coordinates.
Data Translation : Observe how Claude 4.5 Sonnet identifies the most relevant information from multiple forecast periods to create a human-readable summary.
Error Handling : Try entering misspelled city names or international locations (remembering that the NWS API only covers the US) to see how the agent provides helpful guidance rather than crashing

Source Code & Repository

You can access the full implementation of the weather_agent_cli.py and weather_agent_web.py files, along with the environment setup requirements, at the following GitHub repository here : Agentic AI Building Blocks using Amazon Bedrock

Why Use the Web Version?

The web application is particularly useful for non-technical users or for professional presentations. It provides a visual confirmation of the agent’s autonomy and reactivity, allowing you to see exactly how the “brain” (Claude) is directing the “hands” (API calls) to solve the problem

What to Observe

During the execution of the agent, you should pay close attention to how the AI handles the transition from natural language to technical execution:

Planning Intelligence: Notice how the AI recognizes various input types, such as mapping “Seattle” to coordinates or handling ZIP codes like “90210”. Observe how it dynamically generates different API calls based on the specific location type provided.
Data Processing: Watch how the AI converts complex JSON data often containing multiple forecast periods into a human-readable summary. It must identify the most relevant information and add appropriate context or recommendations.
Error Handling: Test the agent’s resilience by entering invalid locations, misspelled city names, or international locations. Observe how it provides helpful guidance rather than failing, noting that the National Weather Service API is limited to US locations

Comparing CLI vs. Web Experience

While both versions use the identical agentic AI logic — relying on the same Claude 4.5 Sonnet reasoning and NWS API integration — they offer distinct advantages depending on the user:

Feature	Command-Line Version (CLI)	Web Version (Streamlit)
Primary Audience	Developers and technical users.	Non-technical users or professional presentations.
Key Strength	Direct, focused interaction ideal for automation and scripting.	Visual, interactive experience with a polished presentation.
Visibility	Shows the raw workflow steps clearly in the terminal.	Provides real-time progress indicators and a sidebar to monitor status.
Visualization	Text-based output of the process.	Step-by-step visualization of the planning, execution, and analysis phases.
Inspection	Best for seeing the immediate code execution.	Includes expandable sections to inspect raw API responses.

Ultimately, the choice between them depends on whether you prioritize developer efficiency and automation (CLI) or visual clarity and user-friendly status tracking (Web).

Key Takeaways

Definition of Agentic AI: The fundamental shift in AI is moving from a “Question → Answer” model (smart encyclopedias) to a “Problem → Plan → Action → Result” workflow. Truly agentic systems are defined by autonomy (making independent decisions), reactivity (responding to environmental changes and errors), and proactivity (taking initiative through multi-step planning).
The AI as a Reasoning Engine: Instead of just generating text, the AI (specifically Claude 4.5 Sonnet) acts as a reasoning engine. It dynamically interprets descriptive user input, such as “largest city in California,” maps it to precise coordinates, and constructs the necessary API URLs rather than relying on hardcoded logic.
The Agentic Workflow: A successful agent follows a reusable four-step pattern: Planning (analyzing input and strategizing), Action (executing technical tasks like API calls), Processing (analyzing raw data for insights), and Response (presenting results in a human-friendly format).
Building without Abstractions: Sophisticated agents can be built using pure Python and the AWS SDK (boto3) without the need for complex frameworks. This “from-scratch” approach helps developers understand every component, from establishing a Bedrock connection to creating an error-resilient architecture that handles network timeouts and invalid data.
Versatile Real-World Applications: The patterns used to build a weather assistant such as coordinate resolution and sequential API execution are directly applicable to other fields like travel planning, emergency management, market analysis, and agriculture

Conclusion

The workshop concludes that the future of artificial intelligence is not just about chatbots, but about agents that can take meaningful actions in the world. By moving beyond static responses and integrating real-time data with AI reasoning, developers can create systems that provide genuine value across any domain. The core principle for success in this new landscape is to start simple and iterate quickly , using foundational building blocks to scale toward more complex multi-agent systems and advanced production environments.

Resources

A special thanks to BeSA (Become a Solutions Architect) for providing a free mentoring platform that enabled me to gain practical, hands-on experience with Generative AI through this workshop. BeSA’s guidance and community support played a key role in helping me strengthen my GenAI and cloud skills.

If you’d like to explore another hands-on agentic AI example using Amazon Bedrock, check out the AWS workshop 1 article. You can read it here:🔗 Building an Intelligent Shopping Assistant with Amazon Bedrock Agents .

Thank you for taking the time to read my article! If you found it helpful, feel free to like, share, and drop your thoughts in the comments; I’d love to hear from you.

If you want to connect or dive deeper into cloud, AI and DevOps, feel free to follow me on my socials:

💼 LinkedIn

❌ X (formerly Twitter)

👨‍💻 DEV Community

🛡️Medium

🐙 GitHub

🌍AWS Builder Profile

AWS Rift Rewind Story: Learning Cloud, Building Projects

dineshrajdhanapathyDD — Wed, 25 Feb 2026 17:45:40 +0000

AWS beginner to deploying a global project via Rift Rewind: secure storage, CloudFront, automated pipelines, live APIs — my journey & tips for builders.

✨ Adding My Personal Touch

I didn’t just follow the templates, I made the site my own:

Customized the design, colors, and layout to match my style
Added Riot Games API integration to fetch live League of Legends data
Included personal content and visuals to make the site unique

This wasn’t just a website — it became my personal playground for learning AWS.

Power Spike Prep

I started by setting up my AWS account safely:

Enabled MFA
Created an admin IAM user
Set up budget alerts

💡 Lesson learned: Security is the foundation. Even small mistakes can be costly in the cloud.

Ward Your Data

I created my first S3 bucket and uploaded my project files securely.

✅ What I Accomplished

Created a private Amazon S3 bucket (with “Block Public Access” enabled)
Verified that files are inaccessible publicly (Access Denied = ✅ security)

💡 Aha moment: Default privacy settings in S3 aren’t just a suggestion — they’re essential for protecting your data.

📝 Level Up Your Code

Time to structure my project:

Organized HTML, CSS, and assets
Applied best practices for project structure
Uploaded everything to S3

🖥️ Personal website customized

💡 Lesson learned: Clean, organized files make everything else easier — from deployment to debugging.

🌍 Global Distribution

I set up CloudFront to make my website fast and accessible worldwide.

✅ What I Accomplished

Understood why distance = latency (ping problem in real life 🌐)
Learned how Content Delivery Networks (CDNs) solve the speed problem
Created a CloudFront distribution connected to my private S3 bucket
Configured index.html as default root object

💡 Aha moment: CloudFront doesn’t just speed up content — it also secures access to your S3 bucket.

🚀 Pro Deploy Mode

I linked GitHub → AWS Amplify for automated deployments.

💡 Lesson learned: Automation is a game-changer. Every change in GitHub now instantly updates my live site.

🎯 Tap Into the Rift

I built my first serverless Lambda function to fetch real-time Riot Games data:

Secured my API key with Parameter Store

Store API Key Securely

Use AWS Systems Manager → Parameter Store
Store as /rift-rewind/riot-api-key (type: SecureString)

Displayed summoner stats & top champions on my site

Create Function URL

Go to Lambda → Function URL → Create
Auth: NONE (so frontend can call it)
Configure CORS :
Allowed origin = your Amplify site domain (must match exactly with https://...))
Allow headers: Content-Type
Allow methods: POST

Test with a small event :

In Lambda Console → Test → Use event:

Use CloudWatch logs for debugging Lambda errors
Riot dev keys expire in 24h → regenerate if broken
If you see it 403 Forbidden, it’s usually a CORS or expired API key issue

💡 Aha moment: Serverless computing feels like magic, you get full backend functionality without maintaining a server.

I levelled up my cloud and development skills: I started by setting up AWS securely with MFA and budget alerts, then stored files safely in S3. I organised my project like a pro, made it globally accessible with CloudFront, and automated deployment using GitHub and Amplify. Finally, I integrated the Riot Games API with AWS Lambda to display live League of Legends data — all while following best practices for security, structure, and performance.

🏆 Victory Lap

I reflected on my journey and published my story:

Shared screenshots of AWS services in action
Documented lessons, tips, and personal experiences.

🎯 Goal for Today

Celebrate completing the challenge and share my journey with the AWS Builder community by writing an article on AWS Builder Center.

🔑 Key Takeaways

Security first: MFA & IAM aren’t optional.
Organization matters: structure saves headaches.
Automation rocks: GitHub + Amplify = effortless deployment.
Global distribution matters: CloudFront = fast, secure, worldwide.
Serverless is powerful: Lambda + APIs = endless possibilities.

💡 Tips for Future Builders

Keep AWS security top of mind
Organize files from the start
Automate deployments with Amplify & GitHub
Test API integrations in small steps
Experiment boldly — serverless lets you fail fast and learn faster

🌟 Final Thoughts

In just 7 days, I transformed from an AWS beginner to a cloud builder:

Deployed globally distributed apps
Integrated real-time APIs with serverless functions
Implemented professional security practices
Built a portfolio-ready project

The Rift Rewind Challenge wasn’t just about building a website — it was about learning cloud architecture, modern workflows, and practical AWS skills. And the best part? My live project now stands as proof of what I can build.

Riot ID in the format GameName#TAG correct region
Should display Summoner Level + Top 3 Champs

In this article, I share my 7-day journey building a cloud-powered Rift Rewind project using AWS, integrating live Riot Games data, and adding my personal design twists to create a fully interactive gaming platform. Check out the full project on the GitHub Repo .

Thank you for taking the time to read my article! If you found it helpful, feel free to like, share, and drop your thoughts in the comments — I’d love to hear from you.

If you want to connect or dive deeper into cloud and DevOps, feel free to follow me on my socials:

💼 LinkedIn

❌ X (formerly Twitter)

👨‍💻 DEV Community

🛡️Medium

🐙 GitHub

🌍AWS Builder Profile

Architecture Diagram: Local Development with Amazon Q + WSL (Ubuntu) + MCP Server for Application…

dineshrajdhanapathyDD — Wed, 18 Feb 2026 20:55:16 +0000

Architecture Diagram: Local Development with Amazon Q + WSL (Ubuntu) + MCP Server for Application Modernization

Amazon Q with VS code IDE

Amazon Q Developer is your AI-powered coding assistant designed to supercharge productivity for developers working on AWS. Think of it as a contextual, cloud-native co-pilot that not only answers your questions but also helps write, debug, and modernize code right inside your IDE.

Amazon Q Developer (Free Tier)

Free Tier

✅ Natural language Q&A on AWS services and cloud development.

✅ Code generation & explanations in supported languages.

✅ AWS documentation search from within your IDE.

✅ Works across local, AWS Builder ID-linked environments.

Amazon Q Developer (Pro Tier)

Pro Tier

✅ Amazon Q Code Transformatio n: Convert legacy Java apps to modern Java on AWS (Spring Boot + Lambda, etc.)

✅ Deep application analysis and modernization recommendations.

✅ Interactive code generatio n with context-aware chat.

✅ Enterprise-ready with SSO suppor t and advanced integrations.

In Visual Studio Code, how can I install the Amazon Q extension?

Available for Windows, macOS, and Linux, Visual Studio Code is a desktop source code editor that is both lightweight and powerful. Make sure Visual Studio Code is installed on your computer. The setup instructions are available in their official manual.

Amazon Q Extension installed

What if you already have Amazon Q and the AWS Toolkit? How can that be updated?

Update the AWS Toolkit if you have already done so. If you have Amazon Q connections, the new Amazon Q extension will be deployed for you immediately, even if they are expired.

There are two ways for you to log in, and this blog examines both of them:

With Builder ID docs for individual users using AWS’s Free Tier
IAM Identity Center with Pro Tier for Professional Users

You can represent your work-self with a workforce identity in IAM Identity Center and your private-self with an AWS Builder ID. These identities function on their own. For more information, see Amazon Q Developer Pricing .

This article focuses exclusively on the Amazon Q Developer Free Tier , highlighting the powerful features available at no cost. With the Free Tier, developers can ask natural language questions, generate architecture diagrams, explore code, and interact with AWS services — all from the terminal or VS Code. While Amazon Q Pro offers advanced features like code transformation, this guide is tailored for those getting started with the free version, making it ideal for learners, hobbyists, and early-stage cloud developers.

Without requiring an AWS account, using the AWS Builder ID

To utilize Amazon Q for free, select this option. You must create an AWS Builder ID even if you do not require an AWS account. Access to specific tools and services is granted by an individual’s AWS Builder ID. Free is the AWS Builder ID. In contrast to Builder ID, you only pay for the AWS resources you use in your AWS accounts. You can use the same email address for both your AWS Builder ID and an AWS account’s root user email.

Click “Continue” after choosing the first “Use for Free” option in step 1.
Click “Proceed to browser” when a pop-up window containing a confirmation code appears.
It will take you to a web browser. Click “Confirm and continue” after making sure the code is the same.
This takes you to the AWS Builder ID sign-up or sign-in page. The sign-up screen will be bypassed if you are already logged into Builder ID.
Permit the IDE extensions to access AWS services.

Amazon Q approved using IDE

After finishing, you can return to your IDE. Using your Builder ID, you have successfully signed into Amazon Q. You should see a Q Chat window open automatically.

Amazon Q chat section in IDE

click on “Amazon Q” in the status bar below. For other options, such as pausing auto-suggestions, opening settings, or signing out.

Started with WSL and Ubuntu: A Developer’s Local

For developers working on cloud-native applications, having a Linux-like environment on a Windows machine can be a game-changer. That’s where WSL (Windows Subsystem for Linux) comes in.

With WSL + Ubuntu , you get the best of both worlds: the power and familiarity of Linux tools and the convenience of Windows. No need for dual-booting or spinning up a virtual machine — WSL gives you a lightweight Linux environment directly inside Windows, perfect for development, automation, and working with cloud platforms like AWS.

In this article, we’ll explore how to:

Set up WSL with Ubuntu on your Windows machine.
Use it for local development and scripting.
Seamlessly integrate it with Amazon Q and MCP Server for cloud modernization workflows.

The command refreshes the list of available packages and their versions from the repositories, ensuring your system knows about the latest software updates.

sudo apt-get update

ubuntu latest updates

The command installs the libfuse2 library, which is needed to run applications (like AppImage files) that rely on the FUSE (Filesystem in Userspace) interface.

sudo apt install libfuse2

installed libfuse2

This command downloads the latest Amazon Q .deb installer securely using curl and saves it as amazon-q.deb for installation on Debian-based systems.

curl — proto ‘=https’ — tlsv1.2 -sSf https://desktop-release.q.us-east-1.amazonaws.com/latest/amazon-q.deb -o amazon-q.deb

This command installs the downloaded Amazon Q .deb file using apt, enabling Amazon Q on your system.

sudo apt install -y ./amazon-q.deb

installed deb file

To access Amazon Q Developer, create a BuilderID here and then enter the command.

q login

q login

Once logged in, just type q in the terminal to start using Amazon Q.

After following the above steps, you’ll have Amazon Qsuccessfully installed and running on your system. By updating your package list, installing required dependencies like libfuse2, and downloading the latest .deb file, you’ve set up the environment smoothly. Once the installation completes, simply launch Amazon Q by typing itq in your terminal. After logging in with your AWS Builder ID, you’re ready to interact with Amazon Q right from your local machine—ask questions, get code suggestions, and streamline your development workflow with ease.

MCP Support on Amazon Q CLI

Amazon Q CLI now includes powerful support for Model Context Protocol (MCP) —a framework designed to assist in the automated modernization of legacy applications. MCP acts as a control plane that coordinates various tools and services involved in analyzing, transforming, and migrating applications to AWS-native architectures.

With MCP support in Amazon Q CLI , developers can:

Scan and assess legacy Java applications
Get AI-powered modernization recommendations
Automate transformations (e.g., move to Spring Boot, Lambda, or containers)
Seamlessly manage the modernization workflow — all from the terminal

This integration allows you to harness the full potential of Amazon Q’s intelligence and the structure of MCP, enabling a streamlined, developer-friendly approach to application modernization.

To install the Astral UV runtime via Snap with classic confinement.

sudo snap install astral-uv --classic

installed Astral UV

create a file called mcp.jsonin~/.aws/amazonq

create a file : vim mcp.json . A powerful text editor used to create or edit files in the terminal.

vim mcp.json

A simple command used to display the contents of a file.

cat mcp.json

{

        "mcpServers" : {

 "awslabs.cdk-mcp-server": {
        "command": "uvx",
        "args": ["awslabs.cdk-mcp-server@latest"],
        "env": {
           "FASTMCP_LOG_LEVEL": "ERROR"
        }
   },
 "awslabs.aws-diagram-mcp-server": {
                "command": "uvx",
                "args": ["awslabs.aws-diagram-mcp-server"],
                "env": {
                        "FASTMCP_LOG_LEVEL": "ERROR"
                },
                "autoApprove": [],
                "disabled": false
        }
}

}

Vim is a powerful, keyboard-based text editor commonly used in Linux environments.

To open/edit a file :

vim filename

To enter insert mode (to start typing):

Press i

To save and exit :

Press Esc, then type_:wq_and hit Enter

To exit without saving :

Press Esc, then type,:q! and hit Enter

Servers still loading …. 2 mcp servers initialized.

awslabsaws_diagram_mcp_server
awslabscdk_mcp_server

Check the command ‘uvx.’

Successfully Initialized:

awslabs/aws-diagram-mcp-server

Provides architecture diagrams and visual workflows for the MCP Server to help you understand the modernization process end-to-end.

awslabs/cdk-mcp-server

Contains AWS CDK ( Cloud Development Kit ) constructs and templates to deploy the MCP Server and related components on your AWS environment.

GitHub repo here awslabs/mcp

The above repositories have been successfully initialized within Amazon Q , enabling you to:

Visualize and interact with MCP server architecture using Amazon Q
Use CDK-based templates to deploy and test modernization workflows
Leverage AI-powered guidance from Amazon Q to navigate, understand, and modernize your applications

All are set now. Start the prompt in Amazon Q.

Amazon Q — Prompting in the Terminal

After launching Amazon Q using the q command in your terminal, you can enter natural language queries.

Prompt:

Launch and connect to an EC2 instance, Create your very own Kubernetes cluster, Monitor cluster creation with CloudFormation.Access your cluster using an IAM access entry make its simple basic diagram

Amazon Q Response (Terminal Output):

I'll help you create a simple diagram for launching an EC2 instance, creating a Kubernetes cluster, monitoring it with CloudFormation, and accessing 
it with IAM. Let me create that for you.


🛠️ Using tool: generate_diagram (trusted) from mcp server awslabsaws_diagram_mcp_server
 ⋮ 
 ● Running generate_diagram with the param:
 ⋮ {
 ⋮ "arguments": {
 ⋮ "code": "with Diagram(\"Simple Kubernetes Cluster Setup\", show=False, direction=\"LR\"):\n # User starting point\n user = User(\"DevOps Engineer\")\n \n # AWS Cloud resources\n with Cluster(\"AWS Cloud\"):\n # EC2 instance for management\n ec2 = EC2(\"Bastion Host\")\n \n # EKS Kubernetes cluster\n eks = EKS(\"Kubernetes Cluster\")\n \n # Worker nodes\n with Cluster(\"Worker Nodes\"):\n workers = [EC2(\"Node 1\"), \n EC2(\"Node 2\")]\n \n # CloudFormation for deployment\n cfn = Cloudformation(\"CloudFormation\")\n \n # IAM for access control\n iam = IAM(\"IAM Role\")\n \n # Flow connections\n user >> ec2\n user >> iam\n iam >> eks\n cfn >> eks\n cfn >> workers\n eks >> workers",
 ⋮ "filename": "simple_kubernetes_setup",
 ⋮ "workspace_dir": "/home/dd"
 ⋮ },
 ⋮ "name": "generate_diagram"
 ⋮ }
 ⋮
 ● Completed in 0.455s

## 🛠️ Using tool: fs_read (trusted)
 ⋮
 ● Reading images:
/home/dd/generated-diagrams/simple_kubernetes_setup.png
 ⋮
 ● Completed in 0.0s

The diagram shows a simple Kubernetes cluster setup in AWS Cloud. Here's what it illustrates:

1. A DevOps Engineer (you) is the starting point, connecting to three key components:
   • A Bastion Host (EC2 instance) for secure remote access to your infrastructure
   • IAM Role for authentication and authorization
   • CloudFormation for infrastructure deployment

2. The CloudFormation stack provisions and manages:
   • The Kubernetes Cluster (Amazon EKS)
   • Worker Nodes (EC2 instances running in a cluster)

3. The IAM Role connects to the Kubernetes Cluster, enabling secure access using AWS IAM authentication

4. The Kubernetes Cluster manages the Worker Nodes (Node 1 and Node 2)

This architecture follows AWS best practices by:
• Using a bastion host for secure access
• Implementing IAM for authentication
• Using CloudFormation for infrastructure as code
• Deploying worker nodes in a cluster for high availability

This simple setup provides all the essential components needed to launch, connect to, and manage a Kubernetes cluster on AWS while maintaining 
security and following infrastructure as code principles.

This prompt shows how you can use Amazon Q like a developer co-pilot in the terminal. By entering a clear query, Q:

Understands your local environment (WSL + Ubuntu)
Connects the flow from your local system , through Amazon Q CLI , into the MCP Server , and finally to AWS services
Automatically generates a clear, labeled architecture diagram to visualize the full modernization path

Reference link :

Amazon Q Developer IDE Setup

MCP configuration

Thank you for taking the time to read my article! If you found it helpful, feel free to like, share, and drop your thoughts in the comments —I’d love to hear from you.

Build a Smart Trading Assistant with Kite MCP Server and Claude Sonnet 4

dineshrajdhanapathyDD — Thu, 12 Feb 2026 13:20:29 +0000

Ai generated image — Charts terminal

AI assist in determining the current performance of your stocks by analysing your portfolio. That future has arrived with Zerodha’s most recent Kite MCP (Model Context Protocol) version. Through the MCP, you can ask Claude to work with your Zerodha account. Through this connection, investors may ask sophisticated market questions in plain English and communicate with their portfolio. This integration will fundamentally alter your investment process, regardless of your level of experience. We will go into great detail in this guide on how to integrate the Zerodha Kite MCP server with Claude and use it to revolutionise our investment workflow.

What is Kite MCP?

Kite MCP Server is a Zerodha-developed backend server program that integrates smoothly with the Kite Connect API. It enables you to programmatically manage your trading account, automate activities, and retrieve market data using a local or hosted server setup. It acts as an intermediary between your application and Zerodha’s trading infrastructure. Kite MCP stands for Model Context Protocol — a new way to bridge your LLM (like Claude Sonnet 4) with Zerodha’s trading tools , such as holdings, orders, P&L, and market data.

Kite MCP Ecosystem

Why It Matters

Traditionally, you’d use the Kite Connect API to:

Write manual code
Query stock data
Analyze it yourself

But with Kite MCP , you can just ask:

“Check the NIFTY 50 index performance for the last 10 trading days?”

“Check my portfolio which stocks perform well?”

And Claude AI responds with insights, using live, contextual data.

How It Works

✅ Acts as a connector : MCP links your LLM to Zerodha’s APIs.
🧠 Provides context : Supplies Claude with current portfolio data, past trades, etc.
🔄 Enables dynamic actions : Claude can not only “see” your data but also suggest or trigger actions like rebalancing or placing orders (if permitted).

Kite MCP turns your AI into a smart stock assistant that understands and acts on your portfolio data — in real time.

Prerequisites:

Prior to starting, make sure you have:

You have Node.js (version 14 or above) installed on your computer.
Your preferred desktop AI helper app is Claude Desktop.
A Zerodha trading account with free access to the Kite Connect API.

Check out the Kite MCP Server on GitHub:

Kite MCP Server MCP Server

GitHub — zerodha/kite-mcp-server: Zerodha Kite MCP server github.com

Setup Instructions:

1. Installing Node.js

First, download Node from the official website https://nodejs.org/en/download, depending on your operating system.

Once downloaded, use the following command to validate its installation:

npm -v

check node.js version

Installing Claude Desktop

You can download Claude directly from the official site, or clone the app repository to install it on your local machine for more control and customization.

Building & Installation (Debian/Ubuntu based)

For Debian-based distributions (Debian, Ubuntu, Linux Mint, MX Linux, etc.), you can build Claude Desktop using the provided build script. Use command-line flags to specify the desired output format (.deb).

# Clone this repository
git clone https://github.com/aaddrick/claude-desktop-debian.git
cd claude-desktop-debian

clone claude-desktop-debian

Build the package (Defaults to .deb)

./build.sh

packages install

Updating the Build Script

When a new version of Claude Desktop is released, the script attempts to automatically detect the correct download URL based on your system architecture (amd64 or arm64). If the download URLs change significantly in the future, you may need to update the CLAUDE_DOWNLOAD_URL variables near the top of build.sh. The script should handle the rest of the build process automatically.

The script will automatically:

Check for and install required dependencies.

complete claude desktop apps

Claude apps installed successfully on your desktop! You can now integrate them with the Kite MCP Server to start using AI-powered portfolio insights in real time.

Uninstallation

Debian Package (.deb)

If you installed the .debpackage, you can uninstall it usingdpkg:sudo dpkg -r claude-desktop

If you also want to remove configuration files (including MCP settings), usepurge: sudo dpkg -P claude-desktop

claude signin page

You can sign in to Claude using your email and password by choosing the “Continue with Google” option on the Claude login page

AI assistant

Clearly mention the AI assistant functionality.
Click ‘I understand’ to continue the process.

pricing model of claude

various plan prices in Claude, but we are using free only.

default page claude desktop

Finally set up my desktop application.

Configuring Claude Desktop for MCP

we are using Claude’s desktop Application, we will need to change the settings file.

To do this:

Go to Claude Settings.
Then go to the Developer Section.
Click on “Edit Config”.

Developer settings

Look for “claude_desktop_config.json”. If the file isn’t already there, please create it with the same name.

config.json file

Insert the following code into it and save the file. This code contains a link to the Kite MCP, which Claude will use to access the remote tools.

{
   "mcpServers": {
       "kite": {
           "command": "npx",
           "args": ["mcp-remote", "https://mcp.kite.trade/sse"]
       }
   }
}

vs code config.json file

To apply the modifications, save the file and restart Claude Desktop.

Troubleshooting Tips

No “kite” option in Tools menu?

• Ensure you’ve saved the config properly and restarted the app.

OAuth errors or “access denied”?

• Double-check your Zerodha API key permissions under the Kite developer dashboard.

Delayed updates in portfolio metrics?

• MCP streams over SSE; verify your network allows long-lived HTTP connections to mcp.kite.trade.

You should now see Kite MCP now showing up inside the setting menu in the prompt window

kite integration claude

You can now check the account from Kite (for example, ask about stock performance), and you should be prompted to visit a link.

login kite link

Navigate to that link, login into Kite, and then you will be required to authorise the Kite MCP app.

Authorize Kite MCP

You should obtain the login successful screen and may navigate back to the Claude desktop app and prompt with Done/Continue to alert it that the login is done so that it can proceed with fetching the desired data.

Kite Login Successful

Testing the Integration

Now that we have successfully added the Zerodha Kite MCP server to Claude, it’s time to test it out.

AI Investment Analysis

Claude Prompt:

“Check the NIFTY 50 index performance for the last 10 trading days?”

This prompt will instruct Claude to:

Connect to the Kite MCP Server
Fetch the historical market data for the NIFTY index
Summarise it in a user-friendly format — such as daily % change, trends, and overall movement.

When we enter the query, Claude correctly finds the Kite MCP AI tools and begins to enumerate the tools it will employ. It then prompts us to log in to Kite using the URL. When we click on the link and enter our account information, we will be logged in.

output:

Nifty Index Performance

Claude AI Response: The Nifty has trended upward over the past 10 days, gaining about 1.52%. It broke above 25,000 on June 6 and has since been consolidating around that level.

Next Claude Prompt:

“Check my portfolio which stocks perform well”

output:

My portfolio performance

Claude AI Response: Your portfolio is well-diversified, and several high-potential stocks are already delivering impressive returns.

Kite MCP’s Data Security Highlights

User-Authorized Access Only

Claude can access only the data explicitly authorised by the user — no blanket access is granted.

No Credential Storage in Claude

Your Zerodha login credentials are never stored in Claude. All authentication is securely handled by Zerodha’s systems.

Read-Only by Design

Current operations are strictly read-only , meaning no trades or changes can happen without the user’s direct action or intent.

Privacy-Centric Architecture

Zerodha designed Kite MCP with privacy and safety as top priorities , ensuring control always stays with the user.

Conclusion

The launch of Kite MCP marks a major leap forward in AI-assisted trading. By integrating with Claude and other MCP-compatible clients, it transforms how traders interact with their portfolios, making insights, analytics, and decision-making as easy as asking a question.

With the Kite MCP server running on Debian using Node.js and connected seamlessly to your Kite apps , you now have a personalised, secure, and intelligent stock assistant right at your fingertips. This setup allows you to analyse your holdings, track performance, and make data-driven decisions — all through natural language.

As AI in finance continues to evolve, this fusion of Zerodha’s secure infrastructure and Claude’s contextual intelligence is not just a tool; it’s a glimpse into the future of smart investing. Stay tuned, explore its full capabilities, and take control of your trading journey like never before.

Thank you for taking the time to read my article! If you found it helpful, feel free to like, share, and drop your thoughts in the comments — I’d love to hear from you.

From Vision to Interaction: A Workplace Dashboard That Works

dineshrajdhanapathyDD — Tue, 10 Feb 2026 15:09:03 +0000

As part of a hands-on challenge, I built a fully interactive, responsive company dashboard from scratch. Designed for TechFlow Innovations , this dashboard acts as a central hub for company updates, team recognition, real-time metrics, events, and tools—all wrapped in a modern, accessible UI. This journey helped me sharpen my front-end, UI/UX, and interactive JavaScript skills while following industry best practices.

📄 GitHub Link: TechFlow Innovations

TechFlow Dashboard

🔧 What I Built

This dashboard wasn’t just a visual project — it combined HTML, CSS, and JavaScript with a modular architecture to handle dynamic content and UI responsiveness. Below is a quick breakdown of the major components I built:

✅ 1. Project Setup

Semantic HTML structure with proper meta tags.
CSS foundation with resets, variables, design tokens, and a responsive grid.
JavaScript module structure with utility functions and interactivity.

✅ 2. Header & Navigation

Company branding with animated logo and gradient styles.
Hamburger menu for mobile.
User profile section with avatar and dynamic greeting.
Search bar with form accessibility.

✅ 3. Responsive Dashboard Grid

CSS Grid layout with named grid areas.
Dynamic 12-column system with responsive adjustments.
Widget containers with consistent spacing, actions, and themes.

✅ 4. Welcome & Quick Links Widgets

Personalised greeting with date/time and rotating motivational quote.
Weather display and quick action buttons.
Quick Links section with icon-based navigation and hover effects.

✅ 5. Events & Announcements

Card-based event layout with urgent badges and filters.
Announcement section with priority tags and interactivity.

✅ 6. Team Spotlight & Recognition

Employee grid with avatars, roles, achievements, and status indicators.
Animated member cards with carousel controls and contact shortcuts.

Events, Announcement and Quick links

✅ 7. Company Metrics & System Status

KPI widgets with animated charts and progress bars.
Real-time status indicators with alerts and maintenance messages.

✅ 8. News & Tools Widgets

Tabbed news system with categories and featured articles.
Tools section with department-based app shortcuts and usage stats.

Company Metrics

✅ 9. Interactivity & Real-Time Features

Auto-refreshing widgets with loading states and retry logic.
Interactive transitions, accessibility-first animations, and performance optimisations.
Offline/online detection with update pausing.

Refresh button

📚 My Journey & Key Learnings

This build helped me sharpen several core engineering skills:

🧠 Modular architecture & scalable layouts with CSS Grid and Flexbox.
🎯 Responsive & mobile-first design across all screen sizes.
🌈 Design systems with reusable design tokens and themes.
♿ Accessibility-first development with semantic HTML and keyboard navigation.
⚙️ Real-time interactivity with JS-based state updates, skeleton loaders, and error handling.

📦 Tech Stack

HTML5
CSS3 (Grid, Flexbox, Variables)
JavaScript (ES6+)
Design Tokens & Responsive Breakpoints
Accessible Animations (prefers-reduced-motion)

🧩 What’s Next?

🌐 Turn this into a React or Vue app with API integration.
⚙️ Use this structure for building a dynamic dashboard with real backend data.
🧪 Add Cypress or Playwright tests for widget behavior.

Special thanks to Axero for inspiring this challenge and highlighting the importance of creating meaningful digital workspaces. Their focus on human-centred design really influenced the direction of this project.

Thank you for taking the time to read my article! If you found it helpful, feel free to like, share, and drop your thoughts in the comments — I’d love to hear from you.

Automating AWS S3 with Terraform

dineshrajdhanapathyDD — Tue, 10 Feb 2026 15:04:25 +0000

Over the past months in my cloud and DevOps journey, I’ve constantly been looking for ways to move beyond theory and gain real, practical, hands-on experience. As an AWS Community Builder , I’ve had the opportunity to learn from industry experts, collaborate with passionate builders, and explore how real-world cloud environments are automated and managed at scale.

While working with AWS services, I realized that manually creating resources in the console is fine for learning but it doesn’t scale in real DevOps environments. That’s when I decided to start my Terraform journey.

I wanted to understand how automation to build, deploy, and manage infrastructure efficiently. Instead of creating cloud resources manually in the AWS Console, Infrastructure as Code (IaC) allows us to define infrastructure in reusable configuration files – making deployments faster, repeatable, and less error-prone.

In this blog, I used Terraform to automate the deployment of an AWS S3 bucket and upload an object to it. I will demonstrate how to install and set up Terraform, configure AWS credentials securely via the terminal, and use Terraform to create and manage S3 buckets. The goal is to automate the provisioning of AWS S3 resources and upload files directly to S3 using Terraform configurations, ensuring efficient and repeatable infrastructure deployment. This was a great hands-on experience that strengthened my understanding of cloud automation and DevOps workflows.

Download and Install Terraform

Head to the official Terraform download page: https://developer.hashicorp.com/terraform/downloads

🍎 MacOS: Select the Apple icon from the top left hand corner of your computer’s menu bar. Select About this Mac , and note whether your Chip says Apple (pick ARM64) or Intel (pick AMD64).

🖼️ Windows: Select the Start button and search for System Information. Note whether your System Type says x64-based or ARM-based PC.

🐧 Linux: Open a terminal and run uname -m. Match the output to the correct Linux package option.

What I Set Out to Do

I demonstrated how to:

Install and configure Terraform
Configure AWS credentials securely using AWS CLI
Create and manage an S3 bucket through Terraform
Upload a file to S3 using Terraform
Destroy resources safely after use

The goal was to automate AWS resource provisioning instead of doing it manually, following real-world DevOps practices.

What is Terraform?

Terraform is an Infrastructure as Code (IaC) tool that lets you build and manage cloud infrastructure using configuration files instead of creating resources manually. You define what you want, such as S3 buckets, servers, networks, or databases, and Terraform automatically provisions them for you based on that blueprint.

What is Infrastructure as Code (IaC)?

Infrastructure as Code means managing infrastructure using code rather than manual setup in the cloud console. Because everything is defined in files, deployments are:

consistent
repeatable
easy to rebuild or modify
less prone to human error

Terraform is one of the most popular IaC tools because it supports multiple cloud providers like AWS, Azure, and Google Cloud , making it ideal for scalable and multi-cloud environments.

What is a Terraform binary?

A Terraform binary is the main executable file that lets you run Terraform commands on your system. It’s the core program your operating system uses to execute Terraform.

What is PATH?

PATH is a list of system folders where your computer looks for programs when you run a command in the terminal. It lets you run tools like terraform without typing their full file location.

Installing Terraform

Terraform is a powerful IaC tool that allows you to define infrastructure using configuration files.

🍎🐧 MacOS / Linux — Add Terraform to PATH

Open Terminal and navigate to the unzipped Terraform folder, e.g.:

cd ~/Downloads/terraform_1.10.x_xxx

(Optional) Confirm location:

pwd

Move the Terraform binary to /usr/local/bin:

sudo mv terraform /usr/local/bin/

Enter your system password if prompted.

You’ve just installed Terraform on your local computer. Now we’ll need to verify we’ve installed it correctly.

🖥️ Windows — Add Terraform to PATH

Open System Properties → Advanced → Environment Variables
Under System Variables , select PATH → Edit
Click New and add:

C:\terraform

Save changes and open a new terminal session.

After installation, verify Terraform Installation

Run the following command:

terraform version

Terraform version output

✔️ Terraform was successfully installed.

📁 Setting Up the Terraform Project

I created my project directory and configuration file:

mkdir ~/Desktop/DD_terraform
cd ~/Desktop/DD_terraform
touch main.tf

What is main.tf?

main.tf is the primary Terraform configuration file where you define how your infrastructure should be built. The main.tf file acts as the blueprint of the infrastructure Terraform will build.

How does Terraform use configuration files?

Terraform uses configuration files (like main.tf) to describe the desired state of your infrastructure and then automatically creates or updates resources to match that state.

I will create a project directory and set up the main Terraform file (main.tf) because it organizes the infrastructure code and defines the resources to be provisioned. This structure makes the project clear, reusable, and easier for Terraform to manage and apply changes.

🧱 Defining the AWS S3 Bucket in Terraform

Inside main.tfI defined the AWS provider and S3 bucket:

Open main.tf in a text editor like VS Code, NotePad++ or TextEdit.
Copy and paste the following code into main.tf

provider "aws" {
  region = "us-east-2 #update the region closest to you
}
resource "aws_s3_bucket" "my_bucket" {
  bucket = "unique-bucket-{yourname}-{random number}" #Ensure the bucket name is unique
}
resource "aws_s3_bucket_public_access_block" "my_bucket_public_access_block" {
  bucket = aws_s3_bucket.my_bucket.id
  block_public_acls = true
  ignore_public_acls = true
  block_public_policy = true
  restrict_public_buckets = true
}

main.tf configuration

Bucket names must be globally unique , so I customized the bucket name accordingly.

What’s in this Terraform configuration?

provider “aws” — Tells Terraform to use AWS as the cloud provider and enables it to interact with AWS services.
resource “aws_s3_bucket” “my_bucket” — Creates an S3 bucket, with my_bucket used as a reference name inside the configuration.
resource “aws_s3_bucket_public_access_block” — Blocks public access to the bucket by enabling security settings that prevent public ACLs and policies.

How are configuration files structured in Terraform?

Terraform configuration files are structured in blocks , where each block defines a specific part of the infrastructure.

Provider blocks specify which cloud or platform (AWS, Azure, GCP, etc.) Terraform will use.
Resource blocks define the actual resources to create or manage, like S3 buckets, servers, or networks.

The configuration is structured in provider and resource blocks, where each block defines a specific part of the infrastructure. This keeps the code modular, readable, and easy to maintain. For example, the provider block connects to AWS, while the S3 resource block defines the bucket.

Visit the Terraform registry’s documentation on S3 buckets.

What is the Terraform registry?

The Terraform Registry is an online library of Terraform providers and modules. It contains documentation, examples, best practices, and configuration options. Developers can also publish modules there, allowing others to reuse them instead of writing everything from scratch.

What can I find in this aws_s3_bucket page?

The aws_s3_bucket page in the Terraform documentation explains how to create and manage S3 buckets. It includes configuration options, properties, examples, and details on how the bucket integrates with other AWS services.

I visited the Terraform documentation to understand how to use the aws_s3_bucket resource. It explains how to configure S3 buckets using arguments like bucket name, ACLs, and tags, and provides examples and best-practice guidance, helping me customize and extend my project confidently.

From the documentation, choose an additional configuration that you might want to add to your S3 bucket or the object you’ve uploaded.
Write your configuration in main.tf
Save your changes to main.tf

Tags

I customized my S3 bucket by adding tags to help identify and organize resources. I used tags Environment = "Dev" to label its purpose and environment. I verified this customization in the AWS S3 console by checking the Tags section, where these labels appear, making the bucket easier to manage and filter in larger environments.

⚙️ Initializing and Planning the Terraform Configuration

I will initialize Terraform and run a plan because initialization sets up the project and downloads the required provider plugins, while the plan previews the changes Terraform will make in AWS. This helps verify the configuration before applying it and reduces the risk of errors or unexpected changes.

I initialized Terraform using:

terraform init

This downloaded the AWS provider plugin and prepared the project.

terraform init output

Next, I previewed the changes Terraform would make:

terraform plan

This execution plan showed which resources would be created before anything was applied.

terraform plan output

I ran terraform plan to generate an execution plan that previews the changes Terraform will make to my AWS infrastructure based on the configuration in main.tf. It shows which resources will be created, updated, or deleted, allowing me to review the configuration safely before applying any real changes.

you get an error?

When I tried to plan my Terraform configuration, I received an error message that says the AWS provider couldn’t authenticate because my credentials were missing or incorrect. This happened because I hadn’t configured the AWS CLI properly or used invalid access keys. Terraform needs valid credentials to connect to AWS and manage resources, so the plan command fails without proper authentication setup.

🔑 Configuring AWS CLI and Credentials

To allow Terraform to authenticate with AWS, I installed AWS CLI and verified it:

aws --version

I will install the AWS CLI , generate access keys, and configure the CLI so Terraform can securely authenticate with my AWS account. This ensures Terraform has the required permissions to create and manage resources like S3 buckets during deployment.

Then configured my credentials:

aws configure

I entered:

Access Key ID
Secret Access Key
AWS Region
Output format (JSON)

This enabled secure programmatic access for Terraform.

🪣 Creating the S3 Bucket with Terraform

Once everything was configured, I deployed the infrastructure:

terraform apply

I will apply my Terraform configuration because this command takes the planned changes and actually creates the defined infrastructure in this case, an S3 bucket on AWS. This is the step where Terraform provisions resources, after which I will verify the bucket in the S3 console to ensure it was created as defined in main.tf.

After reviewing the plan, I confirmed with 'yes', and Terraform created the S3 bucket successfully.

terraform apply output

I ran terraform apply to execute the changes in my configuration and provision resources like the S3 bucket. This command creates, updates, or deletes resources in my AWS account based on main.tf, and it confirms the plan before applying changes turning the code into real infrastructure.

Seeing the bucket appear in AWS was a very satisfying moment 🙂

💎 Uploading an Object to S3 Using Terraform

For the project’s, I uploaded a file to the bucket using Terraform.

I will update my Terraform configuration, reapply it, and document the changes to demonstrate how Terraform detects and applies infrastructure updates. By modifying settings like tags or versioning, I can show how changes are managed safely and reliably using Infrastructure as Code.

Add a New Image File

Download this image. To download it as an image, you can right click on this link and select Save Link As…

I placed image.png inside my project folder and added:

resource "aws_s3_object" "image" {
  bucket = aws_s3_bucket.my_bucket.id
  key = "image.png"
  source = "image.png"
}

Add image resource

Then I reapplied the configuration:

terraform plan
terraform apply

We need to run terraform apply again because any changes made to the configuration must be applied to update the actual infrastructure. Terraform compares the current state with the new configuration and applies only the detected changes ensuring the deployed environment stays consistent with the code. Terraform detected the new resource and uploaded the file automatically.

S3 bucket in AWS console

To validate my update, I confirmed that terraform apply completed successfully, then checked the S3 console and verified that the image.jpg file appeared in my bucket. This confirmed that the Terraform changes were applied correctly and reflected in my AWS environment.

uploaded image in S3 bucket

I validated the upload by downloading and viewing the file inside AWS S3.

🧹 Cleaning Up — Destroying Resources

To avoid keeping unused resources, I removed the infrastructure using:

terraform destroy

Terraform deleted:

The S3 bucket
The uploaded object

terraform destroy output

I also deleted the IAM access key created for the project following security best practices.

📚 Key Concepts I Learned

This project helped me strengthen my understanding of:

✔️ Infrastructure as Code (IaC)

✔️ Terraform providers and resource blocks

✔️ Terraform lifecycle

init → plan → apply → destroy

✔️ State files and execution plans

✔️ Secure AWS authentication via CLI

✔️ S3 storage automation

I also experienced how Terraform enables:

repeatable deployments
reduced manual effort
version-controlled infrastructure
safer cloud operations

GitHub link: https://github.com/dineshrajdhanapathyDD/Terraform-series.git

Conclusion

Terraform is a highly practical and in-demand skill for roles such as DevOps Engineer, DevSecOps Engineer, Platform Engineer, and Cloud Engineer. Through this project, I gained hands-on experience in real-world cloud automation from configuring AWS credentials to provisioning and managing S3 buckets using Infrastructure as Code.

I worked with AWS S3 for storage and AWS CLI for authentication, and strengthened key Terraform concepts including providers, resource blocks, and state files. I also practiced the full Terraform workflow initialization, planning, applying changes, and updating infrastructure safely and consistently.

This experience has motivated me to continue expanding my Terraform journey into areas like EC2 provisioning, VPC and networking automation, bucket versioning and lifecycle rules, and remote Terraform state management.

Overall, this project was a great learning experience and a meaningful step forward in my cloud and DevOps journey

Thank you for taking the time to read my article! If you found it helpful, feel free to like, share, and drop your thoughts in the comments, I’d love to hear from you.

If you want to connect or dive deeper into cloud and DevOps, feel free to follow me on my socials:

💼 LinkedIn

❌ X (formerly Twitter)

👨‍💻 DEV Community

🐙 GitHub

🌍AWS Builder Profile

Getting Started with AWS Developer Tools for Modern DevOps & CI/CD

dineshrajdhanapathyDD — Fri, 29 Aug 2025 19:27:25 +0000

In today’s cloud-native world, DevOps and CI/CD (Continuous Integration and Continuous Delivery) have become essential for faster and more reliable software delivery. AWS Developer Tools offer a robust set of managed services designed to help developers and DevOps teams build, test, and deploy applications securely and at scale.

Press enter or click to view image in full size

Whether you’re a beginner in the cloud or looking to streamline your software lifecycle, this guide introduces the core AWS Dev Tools and related services that support efficient application delivery.

As part of the AWS Community Builders program, I had the exciting opportunity to dive deep into the AWS Developer Tools (DevTools) track. This experience has allowed me to gain hands-on exposure to some of the most powerful tools AWS provides to build, test, and deploy software in a scalable, secure, and automated way.

In AWS, DevTools blog (Developer Tools) refer to services that help developers and DevOps teams build, test, and deploy applications quickly and securely. These tools are especially useful for automating CI/CD pipelines and managing infrastructure as code. In this article, I’d like to share my key takeaways, real-world examples, and insights from working with these services.

What are Developer Tools?

Developer tools are technologies that simplify and speed up software development. They act as a bridge between real-world problems and computer systems by using programming languages, frameworks, and platforms to abstract complexity. Instead of low-level coding, developers use tools like libraries, APIs, and software services to build solutions more efficiently.

Benefits of Developer Tools :

Developer tools help software teams code, test, deploy, and monitor applications more efficiently. Key benefits include:

Better Code Quality: Standardized libraries and frameworks help write clean, high-performance code.
Fewer Errors: Debugging and testing tools catch bugs early, reducing costly production issues.
Cross-Platform Development: Tools enable building apps that run across different devices using a single codebase.
Faster Delivery: Automation and CI/CD tools speed up development and release cycles.
Improved Collaboration: Version control and code review tools support teamwork on complex projects.
Lower Costs: Reusable components and DevOps practices reduce development time and expenses.

What are some types of developer tools?

You use different types of tools to support development workflow. Each tool is often specific to a programming language, platform, or purpose. The following are several common development tools.

Coding Tools

These tools help you write, compile, and build code efficiently. Examples include compilers, builders, libraries, frameworks, and SDKs that accelerate development.

Programming Support Tools

Support tools like IDEs and version control systems streamline workflows, manage projects, and enable collaboration among developers working on the same codebase.

DevOps Tools

DevOps tools connect development and operations, enabling faster releases and continuous feedback. They support CI/CD pipelines, infrastructure as code (IaC), and real-time monitoring.

Software Testing Tools

Testing tools identify bugs, performance issues, and security risks. They include debuggers, profilers, bug trackers, and security scanners like SAST and DAST.

How AWS Supports Developer Tool Needs :

AWS offers a suite of developer tools to help you code, build, test, and deploy applications faster in the cloud. You can:

Use IDEs, SDKs, and CLI tools for seamless AWS integration
Automate DevOps workflows with CI/CD pipelines
Debug and manage code directly from your editor or browser
Get ML-powered code insights and best-practice suggestions
Monitor app performance with built-in observability tools

Press enter or click to view image in full size

🔧 Core AWS Developer Tools Services

1. AWS CodeCommit — A secure, scalable, and managed Git-based source control service, similar to GitHub or GitLab. It enables teams to collaborate on code securely within AWS.

🛠 Example: A fintech startup replaces GitHub with CodeCommit to meet security compliance. Developers push code to a private Git repo directly inside AWS, integrating it with CodePipeline for secure deployment.

We needed our code to stay within AWS due to internal audit rules — CodeCommit made that easy and seamless.

Since AWS CodeCommit is no longer available to new customers, you might want to consider alternative Git repository hosting services like GitHub, GitLab, Bitbucket, or AWS CodeStar Connections with these providers.

2. AWS CodeBuild — A fully managed build service that compiles source code, runs tests, and produces build artifacts ready for deployment. You don’t need to manage your own build servers.

🛠 Example: A media company builds its video processing Lambda functions using CodeBuild, which compiles Python code, runs unit tests, and packages it — all automatically when code is pushed.

Instead of managing Jenkins build agents, we just let CodeBuild handle parallel builds for all our Lambda microservices.

3. AWS CodeDeploy — Automates the deployment of applications to EC2 instances, Lambda functions, or on-prem servers, with built-in strategies like blue/green and rolling updates.

🛠 Example: A logistics firm uses CodeDeploy to update EC2 instances running tracking software, using blue/green deployments to minimize downtime.

We reduced downtime from 10 minutes to under 1 minute by using CodeDeploy’s blue/green strategy.

4. AWS CodePipeline — CI/CD orchestration tool that automates the build, test, and deploy phases.A continuous delivery service that helps you automate the entire release process — from build and test to deployment.

🛠 Example: A SaaS product team configures a full CI/CD pipeline using CodePipeline with CodeCommit, CodeBuild, and CodeDeploy to automate production releases multiple times a day.

No more manual releases — CodePipeline gave us a reliable way to go from pull request to production in 15 minutes.

5. AWS CodeStar — Unified UI to manage software development activities with integrated CI/CD. An integrated development environment for managing software projects on AWS with built-in CI/CD, issue tracking, and collaboration tools.

🛠 Example: A startup bootstraps a new microservice in under 5 minutes using CodeStar, which sets up Git repo, CI/CD pipeline, and a sample Lambda app with monitoring.

For a hackathon MVP, CodeStar helped us skip all the setup and just focus on coding.

6. AWS Cloud9 — Cloud-based IDE for writing, running, and debugging code directly in the browser.A cloud-based IDE accessible from a browser. It includes a code editor, terminal, and debugger — all pre-configured for AWS development.

🛠 Example: A remote DevOps team uses Cloud9 IDE to onboard new hires — developers log in via browser and start coding with preconfigured AWS CLI and credentials.

No more messy laptop setup. We give new devs a Cloud9 URL and they’re ready in minutes.

Since AWS Cloud9 is no longer available to new customers, you might want to consider alternatives like GitHub Codespaces, Visual Studio Code with remote development, or Kiro IDEs with cloud integrations.

7. AWS CodeGuru — ML-powered code reviewer and performance profiler for applications.A machine learning-powered tool that provides automated code reviews and performance profiling to optimize applications.

🛠 Example: An enterprise uses CodeGuru Reviewer to scan pull requests and detect costly Java code inefficiencies — like unnecessary database calls in loops.

It flagged a function making 1000 DB calls in a loop — we saved hours of debugging thanks to CodeGuru.

Recent updates: AWS announced that support for Amazon CodeGuru Security will end on November 20, 2025. After this date, you won’t be able to access the console, service resources, existing scans, or documentation.

Press enter or click to view image in full size

⚙️ Related Topics / Tools Supporting DevOps

To support infrastructure automation and deployment, AWS also offers powerful DevOps-related services:

Press enter or click to view image in full size

1. AWS CloudFormation — Infrastructure as Code (IaC) tool to define AWS resources in YAML/JSON.An Infrastructure as Code (IaC) service to define and provision AWS resources using JSON or YAML templates.

🛠 Example: A DevOps team uses CloudFormation templates to deploy identical infrastructure across dev, staging, and production in different AWS accounts.

With one template, we set up VPCs, EC2, RDS, and IAM roles consistently — no more manual config drift.

2. AWS CDK (Cloud Development Kit) — Define cloud infrastructure using familiar programming languages.Define cloud infrastructure using programming languages like TypeScript, Python, Java, or C#.

🛠 Example: A Python developer uses AWS CDK to define S3, Lambda, and DynamoDB in TypeScript instead of YAML.

We built infrastructure just like writing application code. CDK made it readable, reusable, and testable.

Recent updates: End of Support for Node.js 18.x: Effective November 30, 2025, AWS CDK drops support for Node.js 18.x (which reached EOL on April 30, 2025). This impacts the CLI, Construct Library, and ecosystem tools like JSII and Projen. Upgrade to an active LTS version like Node.js 22.x for security patches and new features.

3. AWS Elastic Beanstalk — Platform as a Service (PaaS) to deploy and manage applications automatically.A Platform-as-a-Service (PaaS) offering that lets you deploy and manage applications without managing infrastructure.

🛠 Example: A team deploys a Django web app using Elastic Beanstalk, letting AWS manage load balancing, autoscaling, and health checks.

We focused on the app, not the infrastructure — Beanstalk auto-managed the rest.

4. AWS SAM (Serverless Application Model) — Framework for building serverless applications.A framework to build, test, and deploy serverless applications using simplified syntax.

🛠 Example: A team creates and tests a serverless application (API Gateway + Lambda + DynamoDB) locally using the AWS SAM CLI.

We simulated API calls locally and deployed serverless stacks with one command using SAM.

5. AWS Amplify — Full-stack development platform for frontend + backend apps.A full-stack platform for developing web and mobile applications with built-in backend support (Auth, API, storage).

🛠 Example: A solo developer builds a React app with Amplify Hosting, Auth, GraphQL API, and file storage — without managing backend servers.

Amplify let me go from idea to full-stack app in 2 days — all hosted and integrated with CI/CD.

Recently, I completed a project using AWS Amplify — a powerful service to build, deploy, and host full-stack applications with ease. With just a few steps, Amplify lets you connect your frontend, backend, and CI/CD for seamless app hosting.

👉 Check out my project and explore how you can host your own apps with Amplify: building-my-serverless-portfolio-website-on-aws

6. AWS X-Ray — Distributed tracing system for debugging and analyzing microservices-based apps.A distributed tracing tool for debugging microservices and understanding application performance bottlenecks.

🛠 Example: A payment service team traces user requests through 10+ microservices using X-Ray, pinpointing a latency issue in an SQS queue handler.

We visualized the request path and found the bottleneck in under 10 minutes with X-Ray.

Press enter or click to view image in full size

📊 Monitoring and Logging Tools for Dev

To ensure application health and compliance, AWS provides powerful observability tools:

Press enter or click to view image in full size

1. Amazon CloudWatch — Monitoring and logging service.Monitors AWS resources and applications, collects logs and metrics, and triggers alerts based on thresholds.

🛠 Example: An e-commerce site tracks EC2 CPU usage and sets up CloudWatch Alarms to scale out when CPU exceeds 70%.

CloudWatch and autoscaling kept our Black Friday site alive without manual intervention.

Amazon CloudWatch Evidently, a service for safely launching features and running experiments with A/B testing, is scheduled for discontinuation on October 17, 2025, after which access to the console, resources, and capabilities will end. Active users can continue using it normally until that date, with critical security patches provided but no support for limit increase requests or new features.

2. AWS CloudTrail — Tracks user activity and API usage. Tracks user activity and API calls, useful for security audits and troubleshooting.

🛠 Example: After a security incident, the IT team uses CloudTrail logs to trace who changed IAM policies and when.

We identified the root cause of a permission error by inspecting the API call logs in CloudTrail.

3. AWS Config — Tracks AWS resource configurations and compliance over time.Monitors configuration changes to AWS resources and checks for compliance with best practices.

🛠 Example: A regulated company uses AWS Config to ensure encryption is always enabled on S3 buckets and logs violations.

With AWS Config, we automatically audit every bucket for compliance and get alerts if policies change.

Press enter or click to view image in full size

🧩 3rd-Party Integrations Support

AWS Dev Tools work seamlessly with popular tools used by developers:

1. GitHub / GitLab / Bitbucket integration — Easily integrate external Git repositories into CodePipeline or CodeBuild.

🛠 Example: A developer team connects GitHub PRs to CodePipeline, so every merge triggers a new build and deployment automatically.

No manual steps — every GitHub merge deploys our app in minutes via CodePipeline.

2. Jenkins integration with AWS Dev Tools — Connect Jenkins pipelines to AWS services for hybrid workflows.

🛠 Example: A company uses Jenkins for job orchestration but offloads heavy builds to AWS CodeBuild, reducing build agent maintenance.

We let Jenkins coordinate the workflow, but let AWS handle the compute for builds.

3. Terraform & AWS — Though not AWS-native, commonly used for IaC with AWS.Not AWS-native, but widely used for Infrastructure as Code alongside AWS.

🛠 Example: A DevOps team provisions complete VPC, ECS, and RDS stacks across multiple environments using Terraform modules.

Terraform gave us reproducible, version-controlled infrastructure across regions and accounts.

4. Docker & Container Registries: Integrate with Amazon ECR for storing and pulling container images.

🛠 Example: A SaaS company packages its microservices as Docker containers and pushes them to Amazon Elastic Container Registry (ECR). These images are then pulled automatically by ECS and EKS clusters during deployment.

“Every time we push a new Docker image to ECR, our CI/CD pipeline deploys it to production in minutes — no more manual uploads or broken versions.”

Press enter or click to view image in full size

Conclusion

Why AWS DevTools Matter

Whether you’re setting up your first CI/CD pipeline or optimising an enterprise-grade DevOps workflow, AWS Developer Tools offer the building blocks you need to succeed. With native integrations, scalability, and security, you can automate your entire development lifecycle on the cloud.

Explore MCP (Model Context Protocol) can be used to access and work with AWS documentation of Dev Tools overview using kiro IDE, making developer tools more efficient and improving the way engineers discover, integrate, and use cloud resources .

Along with accessing documentation, MCP can also integrate with tools like AWS Diagrams to automatically generate architecture visuals. This allows developers to pull AWS service icons directly from documentation, quickly create diagrams without leaving the IDE, and keep their documentation, configurations, and visuals in sync. By combining Amazon Q, MCP, and AWS Diagrams, teams can code, reference AWS docs, and generate architecture diagrams in one place check my blog here

Working with AWS DevTools helped me understand how modern CI/CD, DevOps, and Infrastructure as Code can come together in a unified, secure, and scalable way.

The more I explored AWS Developer Tools, the more I realized they aren’t just for big teams — they’re perfect for anyone who wants to build reliable software delivery systems.

Stay tuned for my upcoming project on this topic — I’ll be sharing a hands-on article soon.

Being part of the AWS Community Builder program gives me the opportunity to explore cutting-edge developer tools and deepen my knowledge in cloud and DevOps. It’s a great way to learn, build, and grow with support from the AWS community.

AWS Community Builders program gave me:

🎓 Learning resources and mentorship
🌍 Global community to share and grow

All AWS builders are welcome and encouraged to apply 👇

Add your name to waitlist for upcoming years — AWS Community Builders

Check before article here : How I Started with AWS and Became an AWS Community Builder

Thank you for taking the time to read my article! If you found it helpful, feel free to like, share, and drop your thoughts in the comments — I’d love to hear from you.

If you want to connect or dive deeper into cloud and DevOps, feel free to follow me on my socials:

💼 LinkedIn

❌ X (formerly Twitter)

👨‍💻 DEV Community

🐙 GitHub

Redis AI Platform: Accelerating the Future of AI with Real-Time Data Intelligence

dineshrajdhanapathyDD — Sun, 10 Aug 2025 19:33:49 +0000

This is a submission for the Redis AI Challenge: Real-Time AI Innovators.

What I Built

🚀 Beyond Simple Chatbots: Building High-Impact AI Applications

In the rapidly evolving landscape of artificial intelligence, the difference between a good AI application and a transformative one often lies not in the model itself, but in the data infrastructure that powers it. The Redis AI Platform represents a paradigm shift from traditional AI architectures, leveraging Redis as a high-performance real-time data layer to unlock unprecedented AI capabilities.

🎯 The Challenge: Moving Beyond Basic AI

While the market is saturated with simple chatbots and basic AI interfaces, the real opportunity lies in building high-impact AI systems that can:

Process and respond to data in real-time (sub-100ms)
Learn and adapt from user behavior instantly
Scale to handle millions of concurrent operations
Provide intelligent recommendations based on complex multi-modal data
Optimize AI model performance through semantic caching

Demo

This project demonstrates how Redis transforms these challenges into competitive advantages.

🏗️ Architecture Innovation: Redis as the AI Accelerator

The Traditional Problem

Most AI applications suffer from:

Slow data retrieval from traditional databases
Cold start problems with recommendation systems
Expensive LLM calls without intelligent caching
Disconnected data silos that prevent real-time learning

The Redis Solution

Our platform leverages Redis’s unique capabilities:

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   Multi-Modal   │    │   Redis Stack   │    │   AI Models     │
│   Data Ingestion│◄──►│   (Real-time)   │◄──►│   (Optimized)   │
└─────────────────┘    └─────────────────┘    └─────────────────┘
         │                       │                       │
         ▼                       ▼                       ▼
┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   Vector Search │    │   Semantic      │    │   Feature       │
│   Engine        │◄──►│   Caching       │◄──►│   Streaming     │
└─────────────────┘    └─────────────────┘    └─────────────────┘

💡 High-Impact Use Cases Implemented

1. Vector Search-Driven Recommendations 🔍

The Innovation:

Real-time similarity matching across text, images, audio, and code
Sub-100ms response times for complex multi-modal queries
Dynamic recommendation updates based on user behavior

Technical Implementation:

// Real-time vector similarity search
const searchResults = await vectorSearch.findSimilar({
    query: userInput,
    modalities: ['text', 'image', 'audio'],
    threshold: 0.85,
    realTimeWeighting: true
});

Business Impact:

10–20x faster recommendations than traditional systems
50% higher engagement through real-time personalization
Seamless multi-modal content discovery

2. Semantic Caching for LLM Optimization ⚡

The Innovation:

Intelligent caching of LLM responses based on semantic similarity
Dramatic reduction in API costs and response times
Context-aware cache invalidation

Technical Implementation:

// Semantic cache with intelligent similarity matching
const cachedResponse = await semanticCache.get({
    query: userQuery,
    context: conversationContext,
    similarityThreshold: 0.9
});
if (!cachedResponse) {
    const llmResponse = await aiModel.generate(userQuery);
    await semanticCache.set(userQuery, llmResponse, {
        ttl: 3600,
        semanticTags: extractTags(userQuery)
    });
}

Business Impact:

80% reduction in LLM API costs
5x faster response times for similar queries
Intelligent cache warming based on usage patterns

3. Real-Time Feature Streaming for ML Workflows 📊

The Innovation:

Live feature computation and streaming to ML models
Real-time model performance monitoring and adaptation
Automated feature engineering pipeline

Technical Implementation:

// Real-time feature streaming
const featureStream = await featureStore.createStream({
    features: ['user_behavior', 'content_engagement', 'temporal_patterns'],
    updateFrequency: 'realtime',
    aggregationWindow: '5m'
});
featureStream.on('update', async (features) => {
    await mlModel.updateFeatures(features);
    await performanceMonitor.track(features);
});

Business Impact:

Real-time model adaptation to changing patterns
90% reduction in feature engineering time
Continuous learning without batch processing delays

4. Collaborative AI Workspaces 👥

The Innovation:

Shared AI contexts across multiple users and sessions
Real-time knowledge graph updates
Collaborative learning from team interactions

Technical Implementation:

// Collaborative workspace with shared AI context
const workspace = await collaborativeAI.createWorkspace({
    participants: teamMembers,
    sharedContext: true,
    realTimeSync: true
});
workspace.on('knowledge_update', async (update) => {
    await knowledgeGraph.addNode(update);
    await notifyParticipants(update);
});

Business Impact:

Team AI intelligence that grows with collaboration
Shared learning across organizational boundaries
Real-time knowledge synchronization

📈 Performance Achievements

Speed Benchmarks

Sub-100ms vector search responses
10–20x throughput improvement through request batching
50–90% latency reduction via intelligent caching
Real-time collaboration with <50ms synchronization

Cost Optimization

80% reduction in LLM API costs through semantic caching
60% lower infrastructure costs through efficient data structures
90% faster development cycles with real-time debugging

Scalability Metrics

Millions of vectors searchable in real-time
Thousands of concurrent collaborative sessions
Automatic scaling based on demand patterns

How I Used Redis 8

🛠️ Technical Innovation Highlights

1. Multi-Modal Vector Search Engine

// Advanced vector search with cross-modal capabilities
const results = await searchEngine.query({
    text: "machine learning algorithms",
    image: userUploadedImage,
    audio: voiceQuery,
    filters: { domain: "AI", recency: "1week" },
    crossModalBoost: true
});

2. Adaptive Learning System

// Real-time behavioral analysis and adaptation
const userProfile = await adaptiveLearning.analyzeUser({
    interactions: recentInteractions,
    preferences: inferredPreferences,
    context: currentSession
});
await personalizeExperience(userProfile);

3. Intelligent Model Routing

// Dynamic routing to optimal AI models
const optimalModel = await modelRouter.selectBest({
    query: userInput,
    performance: realTimeMetrics,
    cost: budgetConstraints,
    latency: responseTimeRequirements
});

🌟 Real-World Applications

E-Commerce Intelligence

Real-time product recommendations based on browsing behavior
Visual search across product catalogs
Dynamic pricing optimization

Content Platforms

Semantic content discovery across multiple media types
Real-time trend analysis and content optimization
Personalized content generation

Enterprise AI

Intelligent document search across organizational knowledge
Real-time collaboration on AI-powered projects
Automated workflow optimization

🚀 Getting Started

Quick Setup

# Clone and start the platform
git clone https://github.com/dineshrajdhanapathyDD/Redis-AI.git
cd Redis-AI

# Start Redis with AI modules
docker-compose up -d redis-stack
# Run the comprehensive demo
npm run demo
# Access the web interface
open http://localhost:3001

Key Features to Explore

Multi-modal search — Try searching across different content types
Real-time recommendations — Watch suggestions adapt to your behavior
Collaborative workspaces — Experience shared AI intelligence
Performance monitoring — See real-time metrics and optimizations

🎯 Why This Matters: The Future of AI

This project demonstrates that the future of AI isn’t just about better models — it’s about intelligent data infrastructure that can:

React in real-time to changing conditions
Learn continuously from user interactions
Scale efficiently without compromising performance
Optimize costs through intelligent caching and routing

The Competitive Advantage

Organizations using this approach gain:

10x faster time-to-insight
Significantly lower operational costs
Higher user engagement through personalization
Scalable AI infrastructure that grows with demand

🔮 What’s Next

The Redis AI Platform represents just the beginning. Future enhancements include:

Federated learning across distributed Redis clusters
Advanced multi-modal AI capabilities
Automated model optimization and deployment
Enterprise-grade security and compliance features

📊 Challenge Results

This project successfully demonstrates:

✅ Beyond Simple Chatbots — Multi-modal AI with real-time adaptation

✅ High-Impact Use Cases — Vector search, semantic caching, feature streaming

✅ Redis as AI Accelerator — Sub-100ms performance with intelligent caching

✅ Production-Ready — Scalable architecture with comprehensive monitoring

✅ Innovation — Novel approaches to AI infrastructure challenges

The Redis AI Platform proves that with the right data infrastructure, AI applications can transcend traditional limitations and deliver transformative user experiences. This is how Redis accelerates the future of AI.

🔗 Resources

GitHub Link : dineshrajdhanapathyDD/Redis-AI: An innovative AI-powered application that leverages Redis as a real-time data layer to accelerate cutting-edge AI workflows.
Live Demo: http://localhost:3001
RedisInsight: http://localhost:8001
API Documentation: /docs/api/README.md
Performance Benchmarks: /docs/performance/README.md
Deployment Guide: /docs/deployment/README.md

Built for the Redis AI Challenge — Demonstrating the power of Redis as a real-time AI data layer.

Thank you for taking the time to read my article! If you found it helpful, feel free to like, share, and drop your thoughts in the comments — I’d love to hear from you.

If you want to connect or dive deeper into cloud and DevOps, feel free to follow me on my socials:

💼 LinkedIn

❌ X (formerly Twitter)

👨‍💻 DEV Community

🐙 GitHub

From Idea to Infrastructure: How Kiro AI Agents Empower My Portfolio Websites Build Smarter

dineshrajdhanapathyDD — Mon, 28 Jul 2025 15:51:53 +0000

One of the most rewarding aspects of being part of the AWS Community Builders program is the chance to gain early access to innovative tools , and today, I’m excited to share one that’s now available in public preview: Kiro.

Through this program, I’ve had the opportunity to attend exclusive webinars, interact with AWS professionals, and learn directly from builders across the globe. These experiences have not only expanded my technical knowledge but also given me a broader perspective on how products are built, used, and evolved.

Kiro is a perfect example of that journey, an agentic development environment that pushes the boundaries of productivity and redefines how we interact with code.

I’ve been testing Kiro extensively, and while it’s still in its early stages, there’s no doubt that it’s already supercharged my productivity as a cloud and DevOps engineer portfolio. Compared to traditional IDEs and even other agentic IDEs I’ve explored, Kiro stands out—not just as a VS Code fork, but as a whole new development experience.

Then I found Kiro—a new kind of AI development agent that didn’t just write code. It collaborated. It adapted. And it helped me turn my idea into a working website using intelligent agent architecture and task list, powered by hooks and steering inputs.

One month ago, I found myself staring at a blank terminal. I had a clear vision: build my own website to showcase my skills as a Cloud and DevOps engineer — from automated pipelines to smart infrastructure demos. I planned it all out: a sleek, professional design, responsive layout, project filtering, SEO, accessibility, and high performance. But turning that idea into a production-ready, secure, and scalable site quickly became overwhelming. Despite my backend expertise, I found myself spending more time tweaking config files and solving deployment quirks than actually shipping features. What started as a portfolio turned into a real-world challenge — one that pushed me to rethink my own workflow.

Enter Kiro, an agentic AI IDE that doesn’t just code — it understands your intent, steers toward your goals, and hooks into your logic. That’s when things changed.

kiro functions

What is Kiro?

Kiro is an AI assistant and IDE built specifically for developers. It combines the power of artificial intelligence with practical development tools to streamline your coding process. Unlike traditional IDEs, Kiro can understand natural language instructions, recommend code changes, and help troubleshoot issues in real-time.

Complexity with Spec-Driven Development

Modern development often drowns in chaos, unclear requirements, scattered documentation, and disconnected tasks. Kiro changes that narrative with a spec-driven development model that brings structure to your workflow. It transforms your initial prompt into clear requirements, system designs, and actionable tasks, all in one place.

Whether you’re planning a microservice or a full-stack app, Kiro lets you collaborate directly within the spec pane, aligning on architecture and goals before writing a line of code. Once finalized, Kiro’s intelligent agents can implement the spec autonomously, while you stay in control of every decision.

Automate Smarter with Agent Hooks

With agent hooks, Kiro allows you to automate repetitive and context-aware tasks. You can delegate operations to background AI agents that trigger on specific events, like saving a file. These agents can generate unit tests, improve code efficiency, or even update documentation, all without breaking your flow.

By using agent hooks, you scale your development process without scaling your mental overhead. The agents work behind the scenes while you stay focused on what matters most, shipping great features.

Kiro’s Spec-Driven Workflow

Kiro bridges the gap between product ideas and technical execution with a structured, spec-driven approach. Each feature begins with a dedicated spec folder containing three essential files:

requirements.md: Captures clear, testable user stories using EARS (Easy Approach to Requirements Syntax), This structured approach brings clarity, testability, and traceability to your workflow. By turning vague ideas into clear, testable requirements, Kiro reduces miscommunication and accelerates development — ensuring alignment between product and engineering from day one.
design.md: Outlines system architecture, data flow, interfaces, and testing strategy—providing a collaborative space for visualizing complex interactions.
tasks.md: Breaks the work into discrete, trackable tasks with real-time status updates, ensuring smooth progress tracking and accountability.

This structured format reduces ambiguity, improves alignment between product and engineering, and streamlines the entire development lifecycle — from feature idea to production-ready code.

Automate with Precision: Agent Hooks in Kiro

In a world where efficiency defines velocity, Kiro’s Agent Hooks bring automation to your IDE in a seamless, intelligent way. Rather than manually initiating routine tasks like linting, generating tests, or updating documentation, Agent Hooks respond to events like file saves or new file creation, executing predefined AI-powered actions behind the scenes.

What Are Agent Hooks?

Agent Hooks are event-driven triggers in your development workflow. When an event occurs, such as saving, creating, or deleting a file, Kiro automatically activates an agent that follows your prompt and performs the associated task. Imagine never having to remind yourself to generate unit tests again. With hooks, that’s your new normal.

Hook created

Why Use Agent Hooks?

By automating repetitive actions, Agent Hooks help you:

🧹 Maintain consistent code quality
🛡️ Prevent security vulnerabilities
⏱️ Reduce manual overhead
🧑‍🤝‍🧑 Standardize team workflows
⚡ Accelerate development cycles

How Agent Hooks Work

Kiro’s automation system runs in three simple steps:

Event Detection: Monitors IDE activity for triggers (e.g. file save)
Prompt Execution: Sends your predefined natural language prompt to the agent
Automated Action: The agent executes the task autonomously

Guide the AI with Confidence: Steering in Kiro

One of Kiro’s most powerful features isn’t flashy—it’s smart, subtle, and scalable. Meet Steering, Kiro’s mechanism for persistent project context. Instead of repeating yourself in every conversation, Steering ensures Kiro remembers your conventions, standards, and architecture automatically.

What Is Steering?

Steering is Kiro’s way of building long-term memory around your project using markdown files located in .kiro/steering/. These files act as blueprints that teach Kiro how your project works, what libraries you use, and how your team writes code. It’s like having a senior engineer embedded in your IDE who never forgets the rules of your codebase.

Why Use Steering in Kiro?

Steering in Kiro isn’t just a configuration — it’s your project’s memory, blueprint, and quality enforcer all in one. Here’s why it’s a game-changer:

✅ Consistent Code Generation

Every API, test, or component adheres to your team’s conventions — automatically.

🔁 Reduced Repetition

You don’t need to keep explaining your preferences. Kiro learns and remembers.

🤝 Team Alignment

Onboard new developers effortlessly. Kiro enforces your standards from day one.

📚 Scalable Project Knowledge

As your project evolves, your documentation grows with it — structured, searchable, and agent-aware.

With Steering, your codebase becomes cleaner, your team becomes faster, and your decisions scale with confidence.

🌐 Model Context Protocol (MCP): Supercharging Kiro with Specialized Context

Modern development doesn’t happen in isolation — it thrives on context, references, and real-time insight. That’s where Model Context Protocol (MCP) comes in. By extending Kiro’s AI with MCP, you’re not just coding — you’re tapping into a live stream of domain-specific intelligence.

🔎 What is MCP?

The Model Context Protocol (MCP) is a communication standard that allows Kiro to connect with external servers packed with specialized knowledge, tools, and APIs. These MCP servers act like power-ups for your AI workflow — feeding it relevant data and making it context-aware.

Imagine having AWS documentation, API specs, or even design system rules instantly accessible by your assistant — MCP makes that possible.

What Can You Do With MCP?

When paired with Kiro, MCP unlocks the following superpowers:

🔍 Live Documentation Access

Browse and retrieve AWS Docs, OpenAPI specs, and developer references within the IDE.
🤖 AI with Domain Awareness

Instead of general answers, Kiro can respond using accurate, official sources from your custom MCP server.
💡 Contextual Code Recommendations

Based on the connected service, Kiro can auto-suggest configurations, cloud commands, best practices, and more.
🧰 External Tool Integration

You can hook in documentation engines, dev portals, internal wikis, or any server that supports MCP’s JSON protocol.

mcp server -aws docs

🧱 Real-World Example: AWS MCP Server

Let’s say you’re building an app on AWS. With the AWS Documentation MCP server, you can:

Ask Kiro “How does S3 versioning work?”
Get code snippets with AWS SDK best practices
Auto-complete IAM policy JSON
Generate Terraform or CloudFormation templates, instantly

All without leaving your IDE or flipping tabs.

Why MCP Matters

MCP transforms Kiro from a smart code assistant into a context-aware development ally. Whether you’re learning cloud tech, building internal tools, or scaling infrastructure, you get AI help informed by your real-world environment.

Personal Portfolio Built

This is a modern, responsive personal portfolio website built for GitHub Pages hosting. The project showcases professional work, skills, and contact information using a clean, performance-focused architecture.

Create a professional online presence for career opportunities
Showcase technical projects with detailed case studies
Demonstrate modern web development skills and best practices
Provide multiple contact channels for potential employers/collaborators
Achieve excellent performance and accessibility scores

Task list

How It’s Built

Core Technologies:

Static HTML5/CSS3/JavaScript — Pure web technologies for GitHub Pages compatibility

Jekyll — Optional static site generator for GitHub Pages integration

Modern CSS — CSS Grid, Flexbox, Custom Properties for responsive design

Vanilla JavaScript — ES6+ modules for interactive features

Key Features:

Responsive Design — Mobile-first approach with CSS Grid layouts

Project Showcase — Dynamic filtering and search functionality

Contact Integration — Forms with third-party service handling (Formspree)

Performance Optimized — Lazy loading, image optimization, minified assets

Accessibility First — WCAG AA compliance with keyboard navigation and screen reader support

SEO Optimized — Structured data, meta tags, and sitemap generation

Architecture:

Component-based CSS using BEM methodology

Modular JavaScript with ES6 modules

File-based content management through YAML data files

Automated build pipeline with GitHub Actions and Lighthouse CI

The project demonstrates modern web development practices while maintaining the simplicity required for static hosting, making it both performant and maintainable. check the live website here : DD-website

Conclusion: From Complexity to Clarity — The Kiro Way

In a world where shipping software often feels like solving a puzzle with missing pieces, Kiro provides the structure, automation, and contextual intelligence developers have long craved. From spec-driven clarity to automated agent hooks, steering-based consistency, and MCP-powered insight, Kiro transforms development from a manual grind into an intelligent, collaborative workflow.

For me, what started as a personal project to showcase my Cloud and DevOps skills evolved into a deep dive into the future of AI-assisted development. Kiro didn’t just help me build faster — it helped me build smarter. And it’s just the beginning.

🌐 Next Up in the Series

“From Spec to Site: Building a Frontend Portfolio with Kiro”

In the next part of this series, I’ll show you how I transformed my Kiro-powered specs into a live, responsive frontend website — complete with automated code generation, component scaffolding, and spec-driven UI logic.

After weeks of refining specs, collaborating with intelligent agents, and streamlining my workflow inside Kiro, I’m excited to share the result: my live cloud and DevOps portfolio website, designed and built using Kiro’s agentic IDE. From layout to logic, every component was generated through spec-driven development, hooks, and steering files — allowing me to focus on what matters most: showcasing real skills, real projects, and real impact.

In the next part of this series, I’ll walk you through how this site came to life — how I turned natural language specs into production-ready frontend code, automated build flows, and shipped a polished site without touching endless config files. Whether you’re building a personal brand or launching a product, this next article will show how Kiro can turn your idea into infrastructure — fast.

Stay tuned. ✨

Thank you for taking the time to read my article! If you found it helpful, feel free to like, share, and drop your thoughts in the comments — I’d love to hear from you.

If you want to connect or dive deeper into cloud and DevOps, feel free to follow me on my socials:

💼 LinkedIn

❌ X (formerly Twitter)

👨‍💻 DEV Community

🐙 GitHub

Building an Interactive Office Scene with Pure CSS

dineshrajdhanapathyDD — Fri, 25 Jul 2025 20:25:29 +0000

This is a submission for Frontend Challenge: Office Edition sponsored by Axero, CSS Art: Office Culture.

Exploring Creativity, Accessibility, and Performance—Without Relying on JavaScript

👋 Introduction

I set out on a creative challenge: Can you build a fully interactive, visually engaging office environment using just HTML and CSS—with minimal JavaScript? The answer turned into one of the most fun and rewarding projects I’ve worked on.

🌟 Inspiration

The idea sparked during a quiet evening while working remotely. I glanced around my real desk—sticky notes, a flickering terminal, a half-full coffee mug, and a wall clock ticking past midnight—and thought, "What if I could bring this physical workspace into code?"

That blend of physical presence and digital interaction inspired me to recreate the essence of a modern workplace using nothing but frontend code.

This interactive CSS art piece simulates a modern digital workspace and demonstrates how far CSS has come—from simple styling to complex interaction and animation. Inspired by human-centered design and digital collaboration tools, this project blends visual storytelling with technical innovation.

What I Built

I created an interactive CSS art piece that depicts a complete office environment using only HTML, CSS, and minimal JavaScript. The project showcases advanced CSS techniques while telling the story of modern office culture through visual elements and animations. Just click the pop-up to start exploring.

Key Features:

Interactive Office Elements: Coffee mug with steam animation, clickable monitor with cycling code snippets, water cooler conversations
Time-Based Simulation: Automatic day/night cycle that affects lighting and office activity levels
Full Accessibility: Keyboard navigation, screen reader support, and motion preference handling
Responsive Design: Optimized for desktop, tablet, and mobile with touch-friendly interactions
Advanced CSS Architecture: Custom properties system, hardware acceleration, and modular organization

Demo

The interactive office scene includes:

🖥️ Dynamic Monitor: Click to cycle through different code snippets and terminal outputs

☕ Smart Coffee Mug: Interactive steam animation with temperature states that change on click

👥 Character Conversations: Water cooler characters with rotating dialogue systems

🕐 Office Clock: Click to advance time and trigger day/night transitions

📝 Interactive Notes: Sticky notes and notice board items with hover effects

🌱 Office Plants: Animated leaves that respond to user interaction

Try it yourself: Hover over elements, use Tab to navigate with the keyboard, or click the help button (?) for technical details.

Want to explore the code? Check out the GitHub repository or click the help button (?) in the demo to see the technical implementation details.

Journey

The Challenge

I wanted to push the boundaries of what’s possible with pure CSS while creating something that felt alive and interactive. The goal was to build a complete office ecosystem that responds to user interaction without relying on heavy JavaScript frameworks.

Technical Approach

1. CSS Architecture Revolution

:root {
  /* Theme System */
  --primary-hue: 210;
  --saturation: 50%;
  --theme-primary: hsl(var(--primary-hue), var(--saturation), var(--lightness));

  /* Animation System */
  --animation-speed-multiplier: 1;
  --animation-duration-base: 0.3s;

  /* Time-Based Variables */
  --time-of-day: 1; /* 0 = night, 1 = day */
  --ambient-light: calc(0.7 + (var(--time-of-day) * 0.3));
}

I built a comprehensive custom properties system that acts like a design system, allowing for dynamic theming and consistent animations across all components.

2. Advanced Animation Techniques

The coffee mug steam uses multiple pseudo-elements with staggered animations:

.coffee-mug__steam::before,
.coffee-mug__steam::after {
  animation: steam var(--coffee-steam-duration) infinite ease-out;
  box-shadow: 
    -3px -10px 0 -2px rgba(255, 255, 255, 0.3),
    3px -15px 0 -1px rgba(255, 255, 255, 0.2);
}

3. Accessibility-First Design

Every interactive element includes proper ARIA labels and keyboard navigation:

<div class="coffee-mug interactive-element" 
     tabindex="0" 
     role="button" 
     aria-label="Coffee mug - click to interact">

4. Performance Optimization

Hardware acceleration and CSS containment ensure smooth 60fps animations:

.animated-element {
  will-change: transform;
  transform: translateZ(0);
  contain: layout style paint;
}

Key Learnings

CSS Can Do More Than You Think: By combining custom properties, advanced selectors, and modern CSS features, you can create complex interactive systems without JavaScript.

Accessibility Enhances Creativity: Adding proper keyboard navigation and screen reader support didn’t limit the design — it made it more robust and usable for everyone.

Performance Matters: Using CSS containment and hardware acceleration made the difference between choppy animations and smooth 60fps interactions.

Modular Architecture Scales: Organizing CSS with clear sections and comprehensive custom properties made the 1000+ line stylesheet maintainable and extensible.

The Result

The final project demonstrates that CSS has evolved into a powerful tool for creating interactive experiences. It’s not just about styling anymore — it’s about building complete user interfaces that are performant, accessible, and engaging.

Technical Stats:

1000+ lines of organized CSS
14 interactive elements
4 time-based states
Full keyboard navigation
Mobile-responsive design
90+ Lighthouse performance score

This project proves that with modern CSS techniques, you can create rich, interactive experiences that rival JavaScript-heavy applications while maintaining better performance and accessibility.

Special thanks to Axero for inspiring this project. Their commitment to human-centered design and digital collaboration continues to shape the way we envision connected, thriving workplaces.

Thank you for taking the time to read my article! If you found it helpful, feel free to like, share, and drop your thoughts in the comments — I’d love to hear from you.

If you want to connect, feel free to follow me on my socials:

💼 LinkedIn

❌ X (formerly Twitter)

👨‍💻 DEV Community

🐙 GitHub

From Vision to Interaction: A Workplace Dashboard That Works

dineshrajdhanapathyDD — Thu, 24 Jul 2025 19:14:02 +0000

This is a submission for Frontend Challenge: Office Edition sponsored by Axero, Holistic Webdev: Office Space

As part of a hands-on challenge, I built a fully interactive, responsive company dashboard from scratch. Designed for TechFlow Innovations, this dashboard acts as a central hub for company updates, team recognition, real-time metrics, events, and tools—all wrapped in a modern, accessible UI. This journey helped me sharpen my front-end, UI/UX, and interactive JavaScript skills while following industry best practices.

📺 Live Demo

🔗 Demo Link: TechFlow Innovations

📄 GitHub Link: TechFlow Innovations

TechFlow Dashboard

🔧 What I Built

✅ 1. Project Setup

Semantic HTML structure with proper meta tags.
CSS foundation with resets, variables, design tokens, and a responsive grid.
JavaScript module structure with utility functions and interactivity.

✅ 2. Header & Navigation

Company branding with animated logo and gradient styles.
Hamburger menu for mobile.
User profile section with avatar and dynamic greeting.
Search bar with form accessibility.

✅ 3. Responsive Dashboard Grid

CSS Grid layout with named grid areas.
Dynamic 12-column system with responsive adjustments.
Widget containers with consistent spacing, actions, and themes.

✅ 4. Welcome & Quick Links Widgets

Personalised greeting with date/time and rotating motivational quote.
Weather display and quick action buttons.
Quick Links section with icon-based navigation and hover effects.

✅ 5. Events & Announcements

Card-based event layout with urgent badges and filters.
Announcement section with priority tags and interactivity.

✅ 6. Team Spotlight & Recognition

Employee grid with avatars, roles, achievements, and status indicators.
Animated member cards with carousel controls and contact shortcuts.

Events, Announcement and Quick links

✅ 7. Company Metrics & System Status

KPI widgets with animated charts and progress bars.
Real-time status indicators with alerts and maintenance messages.

✅ 8. News & Tools Widgets

Tabbed news system with categories and featured articles.
Tools section with department-based app shortcuts and usage stats.

Company Metrics

✅ 9. Interactivity & Real-Time Features

Auto-refreshing widgets with loading states and retry logic.
Interactive transitions, accessibility-first animations, and performance optimisations.
Offline/online detection with update pausing.

Refresh button

📚 My Journey & Key Learnings

This build helped me sharpen several core engineering skills:

🧠 Modular architecture & scalable layouts with CSS Grid and Flexbox.
🎯 Responsive & mobile-first design across all screen sizes.
🌈 Design systems with reusable design tokens and themes.
♿ Accessibility-first development with semantic HTML and keyboard navigation.
⚙️ Real-time interactivity with JS-based state updates, skeleton loaders, and error handling.

📦 Tech Stack

HTML5
CSS3 (Grid, Flexbox, Variables)
JavaScript (ES6+)
Design Tokens & Responsive Breakpoints
Accessible Animations (prefers-reduced-motion)

🧩 What’s Next?

🌐 Turn this into a React or Vue app with API integration.
⚙️ Use this structure for building a dynamic dashboard with real backend data.
🧪 Add Cypress or Playwright tests for widget behavior.

Thank you for taking the time to read my article! If you found it helpful, feel free to like, share, and drop your thoughts in the comments — I’d love to hear from you.

🏃‍♂️ Meet Runner H: The AI Agent Tailors, That Finds & Emails Your Top Cloud/DevOps Jobs

dineshrajdhanapathyDD — Thu, 03 Jul 2025 04:06:34 +0000

This is a submission for the Runner H "AI Agent Prompting" Challenge

What I Built

⚡ The Challenge: Simplifying the Cloud/DevOps Job Hunt

How can we streamline job hunting for entry-level Cloud and DevOps roles — without burning out?

In today’s hyper-competitive market, even talented professionals are overwhelmed by:

🔎 Endlessly scrolling through LinkedIn, AngelList, and niche job boards
📄 Tailoring resumes to pass Applicant Tracking Systems (ATS)
✍️ Writing cover letters that sound human and not copy-pasted
🧮 Tracking job applications manually across messy spreadsheets

That’s exactly why Runner H was born — to reduce anxiety, automate repetitive tasks, and let you focus on being the best version of yourself.

🛠️ Integrated Apps for a Seamless Experience

To tackle this challenge, Runner H connects directly to the tools you already use:

📧 Gmail — Automatically sends personalized job lists to your inbox or recruiter
📁 Google Drive — Stores your resume, PDFs, and project documents securely
📊 Google Sheets — Organizes job applications into a structured, shareable format
🔁 Zapier / n8n / Notion / Slack — Optional integrations for full workflow automation

No more switching tabs 20 times a day.

No more missed follow-ups.

No more generic applications.

Runner H turns job hunting into a streamlined, AI-powered workflow — giving you the edge to land the right role faster.

Runner H

In today’s fast-moving tech world, finding the right Cloud or DevOps job can be overwhelming — especially if you’re just starting out. That’s why I built Runner H, an AI-powered job-hunting assistant designed to streamline the process from start to finish:

✅ Search jobs

✅ Tailor resumes

✅ Write personalized cover letters

✅ Help you stand out

🧩 Why I Created Runner H

I noticed a common pattern among peers and community learners:

They had great skills but struggled to tailor resumes
Job descriptions were too generic, leading to template overload
Cover letters felt like copy-paste fillers, not real reflections

That’s where Runner H steps in — powered by prompt engineering and real-time search, it becomes your personal agent.

🔍 Step 1: Search Jobs with Smart Prompts

Runner H first looks for roles matching keywords like:

Entry-Level DevOps Engineer
Cloud Engineer — Remote
Junior Site Reliability Engineer (SRE)

Prompt:

Act as my personal job search assistant. I’m looking for entry-level or junior Cloud/DevOps Engineer roles (0–1 year experience) or internships in DevOps, SRE, or Cloud Engineering. I have foundational knowledge in AWS, Kubernetes, CI/CD, Terraform, Git, and basic scripting (Python/Bash). I’ve completed hands-on projects, courses, and actively contribute to learning communities. Help me find relevant job openings that welcome freshers or early-career professionals on LinkedIn, AngelList, or other platforms. Prioritize roles with learning potential, mentorship, and cloud-native technologies. Also, help tailor my resume and generate personalized cover letters to match each job

Searching jobs

It scrapes popular job boards like:

LinkedIn — Entry-Level DevOps Jobs

LinkedIn — Cloud Engineer Jobs in Canada

Wellfound (AngelList) — Remote DevOps Jobs

📄 Step 2: Resume Tailoring Suggestions

Once jobs are collected, Runner H analyses job descriptions and offers real-time tailoring suggestions, like:

Clearly list your skills: AWS, Kubernetes, CI/CD, Terraform, Git, Python/Bash scripting.

Highlight any projects: Briefly describe the projects, your role, and technologies used.

Mention community contributions: Any significant learning or collaborative activities in learning communities.

Highlight your AWS Cloud Practitioner certification.

This turns a static resume into a targeted job magnet.

Step 3: Build a Smart Resume Framework

You can prompt Runner H with:

“Create a resume for a DevOps Engineer role including: header, objective, skills, projects, education, and community.”

Here’s the layout:

✅ Header

Ensure it includes your full name, phone number, email address, and LinkedIn profile link.

🎯 Objective

Clear 2–3 line goal aligned to the job

“Aspiring DevOps Engineer with a foundational knowledge in AWS, Kubernetes, CI/CD, Terraform, and Python/Bash scripting. Committed to leveraging hands-on project experience and active learning community contributions to support innovative cloud solutions at [Company Name].”

🛠️ Technical Skills

Group by:

Cloud: AWS, Azure
IaC: Terraform, CloudFormation
CI/CD: Jenkins, GitHub Actions
Containers: Docker, Kubernetes

List skills relevant to the job, such as Cloud Platforms (AWS), Containerization (Kubernetes), Continuous Integration/Continuous Deployment (CI/CD), Infrastructure as Code (Terraform), Version Control (Git), and Scripting (Python/Bash).

🚀 Project Highlights

Briefly describe 2–3 significant projects. Showcase impact-driven projects:

Example: “Deployed a scalable web application on AWS using Terraform and Kubernetes. Automated deployment pipelines using Jenkins for CI/CD.”

🎓 Education

Degree + Certifications (AWS CCP, DevOps Pro, etc.)

Include your degree(s), institution, and graduation date.

🌐 Community

Mention AWS Community Builder, GitHub repos, blogs, or public talks.

Highlight any significant contributions like open-source projects, blogs, or forums.

Write a Personalized Cover Letter

Runner H takes the job description and builds a cover letter using four pillars:

🔓 Introduction

Mention the specific role and why it interests you

Introduce yourself and express your enthusiasm for the position.

🧩 Skills Match

Align key strengths with listed requirements

Identify key requirements in the job description and link them to your skills and experiences.

🏢 Company Connection

Reflect values or projects of the company you admire

Demonstrate knowledge about the company, express interest in its projects, mission, or culture.

✍️ Closing

Invite for interview, express enthusiasm

Thank them for considering your application and express eagerness to discuss further.

If you provide me with specific job postings, I can help generate targeted cover letters for those applications. Feel free to share any job descriptions or additional details you need help with!

Prompts: make templates for common cover letter formats.

Certainly! Here’s a template for a cover letter tailored for entry-level or junior Cloud/DevOps Engineer roles that you can customize for each application:

[Your Name]
[Your Address]
[City, State, Zip]
[Email Address]
[Phone Number]
[LinkedIn Profile URL]
[Date]

[Hiring Manager's Name]
[Company Name]
[Company Address]
[City, State, Zip]

Dear [Hiring Manager's Name],

I am writing to express my interest in the Entry-Level Cloud/DevOps Engineer position at [Company Name] as advertised. With a foundational background in cloud technologies and hands-on experience in AWS, Kubernetes, CI/CD, Terraform, and Git, I am excited about the opportunity to contribute to your team while continuing to grow my skills in a dynamic and innovative environment.

In my recent project [Briefly describe a relevant project or experience], I successfully [Explain what you did and achieved, relating it to the skills relevant to the job]. This experience honed my abilities in [mention particular skills] and demonstrated the impact of effective cloud infrastructure solutions.

[Company Name]'s commitment to [mention company mission, values, or projects you admire] strongly resonates with my career aspirations. I am particularly drawn to [mention any specific aspect of the job/company you are interested in], and I am eager to bring my proactive approach and passion for cloud technologies to your team.

Thank you for considering my application. I am looking forward to the possibility of discussing how I can contribute to the innovative solutions at [Company Name]. I am eager to learn and grow under the mentorship of esteemed professionals in your organization.

Warm regards,

[Your Name]

Tips for Customisation:

\Company Name: Replace with the company’s name you’re applying to.

\Hiring Manager’s Name: Find and add the hiring manager’s name if possible.

Projects/Skills: Tailor the project and skills mentioned to closely match the specific requirements in the job description.

Company Mission/Values: Research the company’s mission statement, culture, or recent projects to demonstrate your genuine interest and make your application stand out.

Feel free to adjust the details to better align with the job posting or to add any personal touches that reflect your enthusiasm and qualifications. If you need further customization or help with multiple specific postings, just let me know!

🧠 Step 5: Smart Prompt for Multi-Job Customization

Applying for multiple jobs? Ask:

“Give 5 resume templates for Cloud/DevOps roles and how to tweak them based on different company types.”

Runner H will respond with:

Generic template
Startup-friendly version
Enterprise-ATS compliant
Remote-only jobs format
Internship/Entry-level focused

Final Tips from Runner H

📌 Resume Customization

Use keywords from the job post
Quantify project impacts (ex: “reduced build time by 20%”)
Add certs, GitHub links, portfolio

📌 Cover Letter Tips

Write with company in mind (not just yourself)
Don’t repeat your resume

📌 General Advice

Keep PDF format
Use clean, ATS-optimized layouts
Avoid jargon overload — be concise

Final Thought

Job hunting shouldn’t be guesswork. With Runner H, you let AI work the process so you can focus on telling your unique story.

The AI Agent Integrated Gmail That Finds & Emails Your Top Cloud/DevOps Jobs

The job hunt is time-consuming, repetitive, and often overwhelming. What if it wasn’t?

Meet Runner H , an AI-powered job-hunting agent that doesn’t just search for jobs — it shortlists, formats, and even emails the top picks to you using your resume and custom preferences.

What Runner H Can Do

Just drop a prompt like this:

“Based on my resume in {RESUME.PDF}, browse Welcome to the Jungle and shortlist the 10 most relevant DevOps and Cloud roles (0–2 years experience, remote only). Create a Google Sheet with job title, company, location, salary (if listed), and link to apply. Then email it to {dineshrajdhanapathy@gmail.com} with the subject: ‘Top 10 Roles You Should Look At 🙏’ and ask for feedback.”

completed the process

⚙️ Integrated Tools

Runner H now supports integration with:

✅ Google Drive — access resume files

✅ Gmail — send curated job lists automatically

✅ Google Sheets — create and update job trackers

✅ Zapier — automate workflows (like syncing to Notion/Slack)

📧 Email Sample

Subject: Top 10 Roles You Should Look At 🙏

Hi Dineshraj,

I have shortlisted some relevant job positions for you that align with your DevOps and Cloud skills, particularly focusing on remote roles for 0–2 years of experience. Although the search yielded limited results on Welcome to the Jungle, here are a few links to explore:

1. [Guild Education DevOps Manager](https://app.welcometothejungle.com/jobs/BowrPZLN)

2. [Platform.sh Chief Revenue Officer](https://app.welcometothejungle.com/jobs/FsrsFjZE)

3. [Remote Engineering Team Leader](https://app.welcometothejungle.com/jobs/sNWCjdxf)

4. [Remote Staff Product Designer](https://app.welcometothejungle.com/jobs/13w7jz1j)

I’ll be eager to hear your feedback or if you’d like assistance in exploring further.

Best regards,

Your AI Assistant

Gmail for me

Google sheet for me

💬 Final Note

With Runner H, you don’t chase jobs — they come to your inbox, fully organized, and ready for feedback.

The future of job applications isn’t reactive — it’s automated, prompt-driven, and AI-powered.

Conclusion: Let Runner H Do the Heavy Lifting

Job hunting today isn’t just about finding roles — it’s about standing out. With Runner H, you’re not alone in this journey. You’re equipped with an intelligent AI agent that can:

✅ Search relevant Cloud & DevOps roles across platforms

✅ Tailor your resume based on live job data

✅ Craft compelling cover letters aligned to each role

✅ Organize top job picks in a Google Sheet

✅ Email you a personalized job list — automatically

Whether you’re an entry-level engineer or a career shifter in tech, Runner H empowers you to focus on what matters most: learning, building, and growing — while the job hunt works for you in the background.

This is just the beginning.

📩 Let Runner H run your job search — so you can run your career.

Thank you for taking the time to read my article! If you found it helpful, feel free to like, share, and drop your thoughts in the comments — I’d love to hear from you.