DEV Community: Girish Bhatia

Kiro Did It: Build a Simple Portfolio Website with Kiro IDE | From Prompt to HTML Prototype

Girish Bhatia — Mon, 25 May 2026 02:04:05 +0000

Hi! I’m Girish, an AWS Community Builder and Cloud Technology Enthusiast with expertise in delivering customer-focused, business-impacting cloud transformation programs of high complexity.

In my previous articles, I’ve explored several powerful features of Kiro IDE and how it is transforming the way developers build software using agentic AI workflows.

Some of the areas I’ve covered include:

Vibe Coding for rapid idea-to-code prototyping
Spec-Driven Development using structured requirements, design, and task workflows
Hooks and Steering Documents to guide consistent code generation and developer workflows
Building real-world applications such as a Customer Lookup API powered by Amazon API Gateway, AWS Lambda, Amazon DynamoDB, and AWS SAM

Through these examples, I’ve demonstrated how developers can build meaningful solutions simply by providing prompts and leveraging Kiro’s intelligent code generation capabilities while still maintaining full control over review, refinement, and deployment.

Since AI governance is equally important—especially for enterprise adoption, I’ve also shared content on:

Secure enterprise rollout of Kiro IDE using AWS IAM Identity Center
AI model, policy, and MCP governance using the Kiro administrative dashboard

In this article, I take a simpler but very practical use case:
Using Kiro IDE to build a simple portfolio website using only HTML and CSS, starting from a simple prompt and following Kiro’s spec-driven workflow from requirements to final prototype.

In this hands-on walkthrough, I used Kiro to create a simple personal portfolio website from a natural language prompt then iteratively refined it using follow-up prompts.

This is a great beginner-friendly example that demonstrates how Kiro uses:

Requirements.md for understanding intent
Design.md for defining technical design
Task.md for execution planning
Iterative prompts for incremental improvements

Let’s walk through it.

What We Will Build

For this hands-on example, let’s use a simple and practical real-world scenario.

Imagine you are a software engineer who wants to create a lightweight personal portfolio website to showcase your professional journey and technical work online.

The goal is to build a simple website that highlights:

Professional Experience — a brief summary of your career journey and domain expertise
Key Projects — selected projects that demonstrate your technical skills and business impact
Contact Information — an easy way for recruiters, peers, or collaborators to reach you
GitHub and Technical Blogs — links to your public code repositories and technical writing

Rather than manually creating HTML and CSS from scratch, I will ask Kiro IDE to generate the entire website prototype using a natural language prompt.

This makes it a perfect beginner-friendly use case to demonstrate how spec-driven development in Kiro can transform a simple idea into a working website by progressing through:

Prompt → Requirements → Design → Tasks → Code → Review → Refinement

Let’s build it.

Step 1: Start with the Initial Prompt

As with most workflows in Kiro IDE, everything begins with a natural language prompt.

The goal here is not to provide detailed technical implementation steps upfront, instead, I clearly describe the business need, expected website structure, and a few technical constraints, then allow Kiro to interpret and translate that into a structured development workflow.

Here is the initial prompt I provided to Kiro:

I am a software engineer with 5 years of experience in the financial/banking industry.

My projects included:

creating a customer serving banking website
a credit card launch project
a regulatory requirement project
currently working on a Generative AI customer service chatbot integrated with company knowledge base.

I would like to create a portfolio website to showcase my job experience.

Create a simple website only using HTML.

Requirements:

Four tabs: About Me, Projects, Contact, and a section to link my GitHub and Technical blogs
single page website
no JavaScript
simple CSS allowed
no testing framework required
simple prototype only

Why this prompt works well

This prompt gives Kiro enough context to understand:

Who the user is → a software engineer with banking and AI experience
What needs to be built → a portfolio website
How it should look → single-page layout with defined sections
Technology constraints → HTML + simple CSS only, no JavaScript
Expected complexity → simple prototype, not a production-grade application

This is an important concept when working with Kiro: better prompts lead to better specs and cleaner generated code.

Step 2: Confirm if This Is a New Feature or a Bug

Once the initial prompt is submitted, Kiro IDE begins by asking an important clarifying question:

“Is this a new feature or a bug?”

For this use case, the answer is straightforward:

New Feature

This small step is important because it helps Kiro determine the appropriate workflow path.

By selecting New Feature, Kiro activates its structured spec-driven development workflow, which guides the implementation through:

Requirements → Design → Tasks → Code

This ensures development starts with intent and structure not just immediate code generation.

Step 3: Generate Requirements

The next step is to ask Kiro to begin with requirements.

Kiro automatically generates a file named:

Requirements.md

Example output:

Why this matters

This step converts a plain English prompt into structured product requirements.

Instead of immediately jumping to code, Kiro first defines:

what must be built
what functionality is required
what technical boundaries exist

This is one of the biggest strengths of spec-driven development.

Step 4: Generate Technical Design

Once the requirements are approved, Kiro moves to the next step in the workflow using the approved requirements as context to generate the technical design.

Kiro generates:

Design.md

Example output:

What happened here?

Kiro translated business requirements into an implementation blueprint.

At this stage, we now know:

the overall architecture
the technologies being used
the major UI components
expected styling principles

This helps reduce ambiguity before code generation begins.

Step 5: Generate Tasks

Once the technical design is approved, Kiro automatically moves to the next step using the design and requirements as context to generate an implementation plan.

Kiro produced:

Task.md

Example output:

Why this is useful
This becomes the execution plan.

Instead of one large generation step, Kiro breaks implementation into manageable tasks making it easier to:

review progress
adjust individual tasks
iterate safely

Step 6: Kiro Creates the Files

Once requirements, design, and tasks are approved, Kiro starts execution.

Generated specification files:

requirements.md
design.md
task.md

Then Kiro executes the tasks and creates the actual website files:

index.html
style.css

At this point, the first working prototype is complete.

Without manually writing a single line of code, we now have a functional single-page portfolio website generated directly from a prompt.

That’s the power of agentic development with Kiro IDE.

At this stage, the prototype is complete.

Initial Website Layout

Once Kiro completed the implementation tasks, the first version of the portfolio website was generated.

The initial prototype included the following sections:

About Me

A concise summary highlighting professional experience in the banking and software industry, along with recent work in Generative AI.

Projects

A dedicated section showcasing key projects, including:
Customer banking website
Credit card launch initiative
Regulatory requirements project
Generative AI customer service chatbot

Contact

A simple contact section containing an email address and a LinkedIn placeholder for future updates.

Links

A section with external links to:

GitHub profile
Technical blog site

Below is the initial website generated by Kiro IDE:

Iterative Improvements Using Follow-Up Prompts

This is where Kiro IDE acts as your coding partner.

Once the initial prototype is generated, you can continue refining the application using simple follow-up prompts—without manually editing files or searching through code.

Update #1: Change Email Address

Prompt: update email under contact section to xxxxxx@cloudwithgirish.com

Kiro identifies the relevant section and updates only the Contact section.

No manual file search or code edits required, just a simple prompt-driven change.

Update #2: Convert Vertical Skills to Horizontal Layout

In the initial design, the Key Skills section used vertical bullet points, which consumed too much screen space.

Prompt: key skills taking too much space, rather than vertical bullets, make it horizontal bullets

Kiro automatically updated both the HTML structure and CSS styling.

Before & After

This small update significantly improved the layout by making the skills section cleaner, more compact, and visually easier to scan.

This demonstrates the real value of iterative development with Kiro: small prompt, targeted change, immediate improvement.

Conclusion

In this article, we used Kiro IDE to build a simple portfolio website and demonstrated how spec-driven development can transform a plain English prompt into a working HTML prototype.

By combining structured requirements, technical design, task-driven execution, and iterative follow-up prompts, we moved seamlessly from idea to implementation without manually writing the initial code.

This example highlights the power of agentic development workflows, where AI moves beyond simple code generation and becomes an active participant in the software development lifecycle helping define requirements, design solutions, execute tasks, and support iterative refinement.

Whether you are building simple websites, prototyping internal tools, or developing enterprise applications, Kiro IDE provides a practical and structured way to accelerate development while keeping developers in control.

Thanks for reading, and I hope you found this article insightful.

Watch the video here:

Thanks,

𝒢𝒾𝓇𝒾𝓈𝒽 ℬ𝒽𝒶𝓉𝒾𝒶

𝘈𝘞𝘚 𝘊𝘰𝘮𝘮𝘶𝘯𝘪𝘵𝘺 𝘉𝘶𝘪𝘭𝘥𝘦𝘳 | 𝘈𝘐 𝘌𝘯𝘨𝘪𝘯𝘦𝘦𝘳𝘪𝘯𝘨
𝘈𝘞𝘚 𝘊𝘦𝘳𝘵𝘪𝘧𝘪𝘦𝘥 𝘚𝘰𝘭𝘶𝘵𝘪𝘰𝘯 𝘈𝘳𝘤𝘩𝘪𝘵𝘦𝘤𝘵
𝘈𝘞𝘚 𝘊𝘦𝘳𝘵𝘪𝘧𝘪𝘦𝘥 𝘋𝘦𝘷𝘦𝘭𝘰𝘱𝘦𝘳 𝘈𝘴𝘴𝘰𝘤𝘪𝘢𝘵𝘦
𝘈𝘞𝘚 𝘊𝘦𝘳𝘵𝘪𝘧𝘪𝘦𝘥 𝘎𝘦𝘯𝘈𝘐 𝘗𝘳𝘢𝘤𝘵𝘪𝘵𝘪𝘰𝘯𝘦𝘳
𝘈𝘞𝘚 𝘊𝘦𝘳𝘵𝘪𝘧𝘪𝘦𝘥 𝘊𝘭𝘰𝘶𝘥 𝘗𝘳𝘢𝘤𝘵𝘪𝘵𝘪𝘰𝘯𝘦𝘳
𝘈𝘞𝘚 𝘊𝘭𝘰𝘶𝘥 𝘛𝘦𝘤𝘩𝘯𝘰𝘭𝘰𝘨𝘺 𝘌𝘯𝘵𝘩𝘶𝘴𝘪𝘢𝘴𝘵

Deploying Kiro IDE Securely in the Enterprise: Identity, Feature Controls, and AI Governance!

Girish Bhatia — Sat, 14 Mar 2026 02:50:02 +0000

Hi! I’m Girish, an AWS Community Builder and Cloud Tech Enthusiast with expertise in delivering customer-focused, business-impacting cloud transformation programs of high complexity.

In my previous articles, I’ve shared many features of Kiro IDE, such as vibe coding, spec-driven development, hooks, steering documents, and building CRUD APIs like a Customer Lookup API powered by Amazon API Gateway, AWS Lambda, Amazon DynamoDB, and AWS SAM. I’ve also shown how you can build solutions by simply providing prompts and letting Kiro’s code generation capabilities generate the code while you control the reviews and deployment.

On March 12, 2026, AWS Kiro announced additional enterprise capabilities that further secure Kiro rollouts. These new features allow administrators to control which AI models are available to developers and manage which MCP integrations are allowed in enterprise environments.

While I was already using AWS Kiro through AWS IAM Identity Center and was familiar with many existing controls such as disabling web search, disabling MCP entirely, and enabling user activity reports, these new features encouraged me to write this article about secure enterprise deployment of Kiro.

A key question I often hear is: How do we securely deploy Kiro at scale?

The answer lies in combining identity governance, feature hardening, monitoring, and human oversight.

In this article, I will walk through key security controls available in the Kiro administrative dashboard and the AWS ecosystem that help organizations deploy Kiro safely.

Identity First: Secure Kiro Access with IAM Provisioning

The foundation of any enterprise deployment is controlled access.
Organizations should provision Kiro access through AWS IAM Identity Center or an enterprise identity provider such as Okta.

Provisioning Kiro via AWS IAM Identity Center or Okta ensures that:

Single Sign-On (SSO) is enforced
Multi-Factor Authentication (MFA) is enabled
Least-privilege permission sets are applied
Only approved AWS roles and accounts have access to Kiro

Why This Matters

This approach provides:

Centralized user subscription management
Controlled onboarding and offboarding
Consistent enforcement of enterprise access policies

In short, identity-based access ensures that AI development tools remain secure and governed across the organization.

Disable Code Reference Suggestions

By default, AI suggestions may reference external code patterns.
Enterprises often choose to disable this feature to avoid:

Open-source licensing concerns
External code ingestion risks
Potential intellectual property exposure

Kiro’s enterprise settings allow administrators to disable code reference suggestions, ensuring that generated code is produced internally rather than referencing external codebases.

Disable Model Context Protocol (MCP)

The Model Context Protocol (MCP) allows AI agents to connect with external tools and contextual data sources.
While powerful, it may introduce risks such as:

Unapproved integrations
Data leakage to external systems

Kiro enterprise settings allow administrators to disable MCP completely.

However, with the March 12, 2026 update, enterprises now have more flexibility. Instead of fully disabling MCP, administrators can control which MCP integrations are allowed through Kiro admin settings.

This provides fine-grained governance over external tool integrations.

Disable Web Search and Web Fetch Tools

Kiro agents can optionally access real-time internet tools.
For enterprises operating under strict compliance frameworks, this may be undesirable.

Kiro admin settings allow organizations to disable web search and web fetch tools.

By disabling these features, enterprises can:

Prevent external data access
Reduce potential data leakage
Maintain regulatory compliance boundaries
Model Availability Governance

Kiro administrators can control which AI models are available to developers.

This capability announced on March 12, 2026 is an important governance feature that allows organizations to restrict model usage to an approved list of models.

This helps ensure that:

Developers only use approved enterprise models
Experimental or unapproved models are not used in production environments
AI usage aligns with internal governance policies

Disable Overage Usage

If not properly controlled, AI usage can scale rapidly across teams.
Kiro includes a safeguard that prevents usage from exceeding defined limits.

Organizations can protect their AI budget by disabling overage usage, ensuring that developers cannot continue using Kiro after reaching the configured monthly limits.

This provides predictable cost management and financial governance.

Monitor with CloudTrail and CloudWatch

In addition to Kiro dashboard controls, AWS-native monitoring should also be enabled.

Services such as AWS CloudTrail and Amazon CloudWatch provide tracking and operational monitoring for Kiro usage.

These services can help track:

Administrative configuration changes
Access activity
Usage patterns
Operational events

Together, they create a complete visibility layer for Kiro operations.

Additional Governance Features

There are several additional features that organizations can configure to strengthen governance, including:

User activity reports
Exporting activity reports to an Amazon S3 bucket
Prompt logging for auditing and security analysis
Establishing internal policies for Supervised Mode usage within Kiro IDE

These capabilities help organizations maintain auditability, compliance, and responsible AI usage.

See It in Action

From my own Kiro account provisioned through AWS IAM Identity Center, here is a view of how some of these administrative settings appear.

As you can see, many of these controls are simple to configure using on/off toggles within the Kiro administrative dashboard.

Conclusion

In this article, I explored how enterprises can deploy Kiro IDE securely at scale by combining identity governance, feature controls, monitoring, and operational guardrails.

Using AWS IAM Identity Center with Kiro enables secure, centralized team subscriptions and scalable access management across your organization. This approach removes the burden of individual account management from developers and IT teams, allowing them to focus on building, collaborating, and delivering high-value solutions.

Whether you’re provisioning users, organizing groups, assigning subscriptions, or enforcing MFA, IAM Identity Center acts as an enterprise-grade access manager, ensuring that every team member has the right permissions without manual overhead.

Thanks for reading, and I hope you found this article insightful.

Thanks,

𝒢𝒾𝓇𝒾𝓈𝒽 ℬ𝒽𝒶𝓉𝒾𝒶
𝘈𝘞𝘚 𝘊𝘦𝘳𝘵𝘪𝘧𝘪𝘦𝘥 𝘚𝘰𝘭𝘶𝘵𝘪𝘰𝘯 𝘈𝘳𝘤𝘩𝘪𝘵𝘦𝘤𝘵
𝘈𝘞𝘚 𝘊𝘦𝘳𝘵𝘪𝘧𝘪𝘦𝘥 𝘋𝘦𝘷𝘦𝘭𝘰𝘱𝘦𝘳 𝘈𝘴𝘴𝘰𝘤𝘪𝘢𝘵𝘦
𝘈𝘞𝘚 𝘊𝘦𝘳𝘵𝘪𝘧𝘪𝘦𝘥 𝘎𝘦𝘯𝘈𝘐 𝘗𝘳𝘢𝘤𝘵𝘪𝘵𝘪𝘰𝘯𝘦𝘳
𝘈𝘞𝘚 𝘊𝘦𝘳𝘵𝘪𝘧𝘪𝘦𝘥 𝘊𝘭𝘰𝘶𝘥 𝘗𝘳𝘢𝘤𝘵𝘪𝘵𝘪𝘰𝘯𝘦𝘳
𝘈𝘞𝘚 𝘊𝘭𝘰𝘶𝘥 𝘛𝘦𝘤𝘩𝘯𝘰𝘭𝘰𝘨𝘺 𝘌𝘯𝘵𝘩𝘶𝘴𝘪𝘢𝘴𝘵

How to Set Up a Kiro Team Subscription Using AWS IAM Identity Center!

Girish Bhatia — Wed, 18 Feb 2026 02:20:41 +0000

Quick Update: Since publishing this article, AWS has expanded Kiro SSO capabilities. Beginning with Kiro IDE version 0.9.40 (released February 12, 2026), organizations can now integrate external identity providers such as Okta and Microsoft Entra ID, in addition to AWS IAM Identity Center. This allows developers to sign in using their existing corporate credentials while giving enterprises more flexibility in identity management. The walkthrough below continues to focus on IAM Identity Center, but organizations now have additional SSO options depending on their enterprise identity platform.

Hi! I’m Girish, an AWS Community Builder and Cloud Tech Enthusiast with expertise in delivering customer-focused, business-impacting cloud transformation programs of high complexity.

In my previous article, I shared how I used AWS Kiro’s vibe coding feature to build a Customer Lookup API powered by Amazon API Gateway, AWS Lambda, Amazon DynamoDB, and AWS SAM.

In another article, I explored Kiro hooks using a simple HelloWorld Python program. I demonstrated how hooks can automatically update a README.md file whenever the Python code is modified.

There is so much more you can do with Kiro. However, first things first, you need to log in to Kiro to start building creative, GenAI-assisted solutions.

Kiro provides multiple ways to log in and set up a subscription:

The first three options are individual subscription models. This means you sign up independently and pay monthly based on the plan you select.

The Organization Single Sign-On option is designed for team-based access. In this model, your account is provisioned by your cloud administrator, and you are provided with a dedicated login URL. This enables centralized access management and consolidated billing.

In this article, I will walk you through the step-by-step process of configuring Kiro using a Team subscription, enabled through AWS IAM Identity Center.

What Is an Organization (Team / Enterprise) Subscription?

This option is used when your company centrally manages access using AWS IAM Identity Center. In this model:

Kiro subscriptions are managed at the organizational level
Users and groups are provisioned in advance
You must sign in using a company-specific URL

What Is AWS IAM Identity Center?

AWS IAM Identity Center is a centralized identity management service that enables organizations to manage workforce access to AWS accounts and cloud applications.

It allows administrators to:

Create or connect user identities
Organize users into groups
Assign permissions across multiple AWS accounts
Enable Single Sign-On (SSO) for supported applications

In the context of Kiro, AWS IAM Identity Center enables secure, centralized access management and subscription control for teams and enterprises.

Individual vs Team / Organization Subscription

Architecture/Design

At a high level, the architecture/Flow diagram as below:

AWS IAM Identity Center --> Kiro Team Subscription --> Kiro Login using org SSO

Step-by-Step: Configuring Kiro Team Subscription

Step 1: Enable IAM Identity Center

Search for IAM Identity Center
In the AWS Management Console, type IAM Identity Center and open the service.

Enable Identity Center
Click Enable to activate IAM Identity Center.

Choose a Region
Select the AWS region where Identity Center will be managed.

Step 2: Create a Group for Kiro Users

Navigate to Groups
Click Create group
Enter group name:

I will name it as kiro_dev_group

Step 3: Create a User and Assign to the Group

Create the User

Go to Users → Add user

Enter Username, Email, First & Last Name

Assign User to Group
Assign to kiro_dev_group

Review and Create

Confirm details and create the user
Review confirmation message

Step 4: Review Email and Complete User Setup

Check Invitation Email

Set Password and Configure MFA

Click the email link, set password, and configure MFA

✅ User and group setup complete

Step 5: Enable Kiro Subscription

Navigate to the Kiro Subscription Page
Open the Kiro admin or subscription page.

Review Pricing and Select Plan

For this walkthrough:
Select Pro (or Enterprise based on your org)

Enable Kiro

Activate Kiro for your organization.

Step 6: Assign Users or Groups to Kiro

Instead of individual users, assign the group.

Click Add users or groups
Select the subscription plan
Choose: kiro_dev_group
Assign the group

Step 7: Review Organization Sign-In URL

After configuration, note the IAM Identity Center sign-in URL:
https://xxxxxxxxxx.awsapps.com/start

Step 8: Sign In to Kiro Using Organization Login

Open Kiro IDE

On the login screen:

Select Sign in with your organization

Enter Organization URL

Paste your Identity Center URL and continue.
Confirm Access
Authenticate using:

IAM Identity Center credentials
MFA (if prompted)

You are logged in and now part of the Kiro Enterprise Plan

Conclusion

In this article, I demonstrated how using AWS IAM Identity Center with Kiro enables secure, centralized team subscriptions, providing scalable access management for your organization. This setup shifts the burden of individual account management away from developers and IT, allowing teams to focus on building, collaborating, and delivering high-value solutions.

Whether you’re provisioning users, organizing groups, assigning subscriptions, or configuring MFA, IAM Identity Center acts as your enterprise-grade access manager, ensuring every team member has the right permissions without manual overhead.

By starting with a single group and gradually scaling to include multiple teams and subscription plans, you can establish a streamlined environment where onboarding, access control, and billing are automated and consistent across your organization.
Experiment with these steps and see how Kiro, combined with IAM Identity Center, transforms team development workflows and simplifies GenAI-assisted coding at scale.

Generative AI is transforming the way development happens, and tools like Kiro make this process faster and more collaborative. While managing multiple users and subscriptions may seem complex, IAM Identity Center provides the governance and security your organization needs.

I believe this is just the beginning, and these tools will continue to evolve rapidly!

Thanks for reading, and I hope you found this walkthrough insightful.

Watch the video here:

Thanks,

𝒢𝒾𝓇𝒾𝓈𝒽 ℬ𝒽𝒶𝓉𝒾𝒶
𝘈𝘞𝘚 𝘊𝘦𝘳𝘵𝘪𝘧𝘪𝘦𝘥 𝘚𝘰𝘭𝘶𝘵𝘪𝘰𝘯 𝘈𝘳𝘤𝘩𝘪𝘵𝘦𝘤𝘵
𝘈𝘞𝘚 𝘊𝘦𝘳𝘵𝘪𝘧𝘪𝘦𝘥 𝘋𝘦𝘷𝘦𝘭𝘰𝘱𝘦𝘳 𝘈𝘴𝘴𝘰𝘤𝘪𝘢𝘵𝘦
𝘈𝘞𝘚 𝘊𝘦𝘳𝘵𝘪𝘧𝘪𝘦𝘥 𝘎𝘦𝘯𝘈𝘐 𝘗𝘳𝘢𝘤𝘵𝘪𝘵𝘪𝘰𝘯𝘦𝘳
𝘈𝘞𝘚 𝘊𝘭𝘰𝘶𝘥 𝘛𝘦𝘤𝘩𝘯𝘰𝘭𝘰𝘨𝘺 𝘌𝘯𝘵𝘩𝘶𝘴𝘪𝘢𝘴𝘵

Kiro did it: Building a Credit Card Account Status Check Lambda Using the Kiro IDE!

Girish Bhatia — Sun, 25 Jan 2026 15:46:33 +0000

Hi! I’m Girish, an AWS Community Builder and Cloud Tech Enthusiast, with expertise in delivering customer-focused and business-impacting cloud transformation programs of high complexity.

In my previous articles, I shared various Kiro features like vibe coding, specs driven development, steering docs and hooks.

I also demonstrated various examples of Kiro use cases like creating a CRUD API, using Kiro to modernize my portfolio web site and using Kiro Powers to create postman collection.

In this article, I’ll demonstrate how I used the Kiro IDE to build a real-world banking Lambda function - a Credit Card Account Status Check Lambda - and how Kiro’s context-aware, agentic approach helped me go from idea to a clean, test ready implementation for enterprise workflow.

What Did I Build and Why?

In my prior posts, I demonstrated various other uses cases of Kiro like creating APIs, UI, Modernize my portfolio website and using Kiro Powers. This time I wanted to build a serverless function that contains business logic and does not integrate with any database. The intent of this function is to have a business function that can be triggered by other events and services as needed by the workflow.

With this use case in consideration, I build a credit card account status check Lambda function as account status check is a common patter in banking and credit card platforms.

This Lambda is responsible for determining whether a card account is eligible to process transactions based on signals such as:

Account status (active vs closed)
Temporary freezes
Fraud blocks
Delinquency thresholds
Card expiration

This type of logic is typically part of authorization or decisioning workflows, and it’s a great example of pure business logic that:

Does not require DynamoDB
Does not require API Gateway
Can be triggered via events or scheduled checks

I chose this use case intentionally because it allows us to focus on decision logic and architecture, not infrastructure plumbing.

Why Use Kiro for This?

What makes this exercise interesting is not just what we’re building, but how we’re building it.

Instead of starting with:

Boilerplate SAM templates
Manual handler code writing
Trial-and-error refactoring

I let Kiro act as my peer engineer, guiding the implementation through prompts, reasoning about the workspace, and generating code that aligned with real-world banking patterns. Kiro not only generated a fully functional code but also create an Infra as Code template to build and deploy the Lambda function using AWS SAM. In addition, it created specs and design for the function as well.

Architecture

At a high level, the architecture is intentionally simple:

AWS Lambda (Python) for business logic
AWS SAM for infrastructure as code
Event-driven invocation (local testing or scheduled execution)

Reference Architecture Diagram

How Kiro and I Built the Lambda

I started by providing Kiro a prompt.

I explained in detail to Kira the intent of what the Lambda should do and why!

Here is the exact prompt I used:

Kiro responded by:

Evaluating the existing workspace
Suggesting a clean project structure
Generating a Python-based Lambda handler
Creating a SAM template aligned with best practices

What stood out immediately was that Kiro did not blindly generate code.

It reasoned about:

Business rules
Decision paths
Environment-based configuration
Security and clarity

The entire experience felt like pair programming with a senior engineer.

Business Logic in Action

The Card Account Status Check Lambda evaluates multiple conditions and produces a clear decision outcome:

Approved
Declined
Review

Kiro created a detailed specs in the form of requirements file. An example shown below:

These specs clearly outline the requirements used by Kiro to build the business function.

Here is an example of AWS SAM template generated by Kiro:

Here is the sample function code generated by Kiro:

Testing the Lambda Locally

Thanks to Kiro as it generated a SAM template. Using SAM, I can test this Lambda function locally by passing multiple test events and Yes, those test JSON was also created by Kiro!

Multiple JSON test files created by Kiro allowed me to test below scenarios:

Active account
Frozen account
Fraud-blocked account
Delinquent account
Expired card

Example of test case run locally using AWS SAM.

Once fully built, Kiro provided me final status message of the build process confirming and summarizing what all have been built.

The full function build, including test file generation, was completed in about 60 minutes through peer-style prompt refinement with Kiro.

Conclusion

In this article, I demonstrated how the Kiro IDE can be used to build a real-world Credit Card Account Status Check Lambda—not as a proof of concept, but as a practical, enterprise-aligned implementation.

What stood out most was the quality of collaboration:

Kiro reasoned about business intent
Generated clean, explainable code
Adapted as requirements evolved
Responded like a true peer programmer

Generative AI isn’t replacing good coding, design or testing practices; it’s enhancing them. And with tools like Kiro, building business functions can feel like working alongside an experienced software engineer who understands your workspace.

As agentic AI tools continue to mature, capabilities like specs driven development, context-aware reasoning, and explainable outputs will become essential especially in regulated domains like banking.

I believe this is just the beginning, and tools like Kiro will continue to redefine how we design & build cloud-native systems.

Thanks for reading, and stay tuned for more hands-on AWS and Kiro content!

Watch the video here:

Thanks,

Kiro Did It: Using Powers to Test Your APIs in Postman!

Girish Bhatia — Wed, 17 Dec 2025 02:47:22 +0000

Hi! I’m Girish, an AWS Community Builder and Cloud Tech Enthusiast, with expertise in delivering customer-focused and business-impacting cloud transformation programs of high complexity.

In my previous articles, I shared various Kiro features like vibe coding, specs driven development, steering docs and hooks. All these features were available prior to reinvent 2025.

This time, I am writing about a feature of Kiro that was announced during reinvent 2025. This feature is Kiro Powers!

I will use Postman Power in Kiro to demonstrate how you can use agentic AI to create API test collection and then use it in Postman to validate your API endpoints.

What Did I Build and Why?

A few weeks back, I built a CRUD API for customer look up using AWS Kiro. Based on my prompt, Kiro created multiple API endpoints to lookup, create, update and delete customer information. It created a tech stack including API Gateway, Lambda and Dynamo DB. An IaC code using AWS SAM was created as well to build and deploy this solution to AWS Cloud. At that time, I used Postman to validate the API endpoints and created the needed postman collection manually.

Fast Forward to December, post reinvent 2025, now Kiro supports Powers and one of the powers is Postman Power for which Postman, the creator of the tool, is the creator of this power.

I decided to try out this Postman power and used the same API endpoints to validate this. With this Postman power in action, Kiro created the entire collection in minutes.

This wasn’t just a prototype or proof of concept, it was an opportunity to see how Kiro’s AI-driven coding capabilities could help me automate the repetitive tasks of API validation collection creation, thus saving the time and allowing me to focus on ensuring that APIs are built correctly and to the specs.

Architecture

What Are Kiro Powers

Kiro Powers are modules created in partnership with developer tool providers to supply tool-specific context and expertise to agentic AI–based development workflows. In simple terms, Powers combine tool-specific MCPs and steering documentation into a single unit that guides the agentic AI with the right context resulting in more accurate responses and higher-quality code or artifact generation.
There are many different Powers available today, including Postman, Figma, Terraform, Stripe, and more.

In this article, I’ll be using the Postman Power with Kiro to demonstrate how it can generate a complete API collection.

How Kiro and I Did It!

I started by providing Kiro a prompt.

Here’s the exact prompt I used:

“I have a customer lookup API. Using Postman Powers, create a collection for getCustomer API.”

That’s it. No schema definitions. No OpenAPI spec. No manual instructions.

What I found interesting that instead of blindly creating something new, Kiro responded by evaluating my existing workspace. As part of this assessment, it found the Customer Lookup API and confirmed that it will be building the API collection for this Customer Lookup API.

Full CRUD Collection in Minutes

Kiro recognized that my Customer Lookup API includes multiple endpoints such as Get Customer, List Customers, Create Customer, Update Customer, and Delete Customer. It automatically created a Postman API collection for these endpoints, ensuring that each request includes the appropriate parameters and is ready to run.
Here are the API endpoints Kiro created the collection for:

Get Customer – Retrieve a customer by ID
List All Customers – Retrieve all customers
Create Customer – Add a new customer
Update Customer – Modify an existing customer
Delete Customer – Remove a customer

Kiro, not only created the collection but also included Environment variables for endpoint portability, it also added API key–based authentication headers.

Testing the Collection with Postman

Once Kiro confirmed that the collection had been created, I wanted to test it using Postman.

However, I couldn’t initially find the collection in my local workspace. Since Kiro was acting as my peer programmer, I decided to ask where the collection had been saved.

As shown in the screenshot below, Kiro responded just like a true peer programmer, explaining that the collection was saved directly in my Postman environment. This eliminated the extra step of manually importing the collection into Postman and allowed me to start testing immediately.

View from the Postman

Here is the view in my Postman environment. I can see this collection in there, it was added by Kiro.

Get Customer Validation

This is the result from Get Customer API invoked using the collection.

![Image getcust(https://dev-to-uploads.s3.amazonaws.com/uploads/articles/4wpqq3inzh4mabhcb7il.png)

Create Customer Validation

This is the result from Create Customer API invoked using the collection.

When I run the Get Customer again, I get the updated list including the one customer, I just created.

Conclusion

In this article, I demonstrated how Kiro Powers, combined with Postman Powers, can accelerate API development and testing by eliminating repetitive setup work. Instead of spending hours manually creating requests and configuring environments, Kiro evaluated my existing workspace and generated a complete Customer API collection with all required endpoints ready to use.

The real magic was in the feedback loop. Kiro didn’t just create requests—it understood the context of the existing API, generated a well-structured Postman collection, and clearly explained what was created and why. It felt less like a tool and more like a technical partner supporting the API testing workflow.

What started as a simple request to generate a Postman collection quickly became a practical demonstration of how agentic AI can improve everyday developer workflows. With automated tests, environment variables, authentication headers, and validation already in place, the result was a fully usable Postman collection that could be tested immediately.

Whether you’re building a new API, refining an existing one, or standardizing collections across teams, Kiro’s blend of AI-assisted automation and contextual understanding makes it easier than ever to move from idea to tested implementation—fast, accurate, and reliable.

Generative AI isn’t replacing good API design or testing practices; it’s enhancing them. And with tools like Kiro, even routine tasks like creating Postman collections can feel like working alongside an experienced API engineer who understands your workspace.

Generative AI is transforming how APIs are built and tested, and tools like Kiro are making that transformation practical. While increased AI-generated artifacts can introduce new challenges, features like context awareness, spec-driven workflows, and automated validation help maintain quality and consistency.

I believe this is just the beginning, and these tools will continue to evolve rapidly.

Thanks for reading, and I hope you found this insightful.

Watch the video here:

Thanks,
𝒢𝒾𝓇𝒾𝓈𝒽 ℬ𝒽𝒶𝓉𝒾𝒶
𝘈𝘞𝘚 𝘊𝘦𝘳𝘵𝘪𝘧𝘪𝘦𝘥 𝘚𝘰𝘭𝘶𝘵𝘪𝘰𝘯 𝘈𝘳𝘤𝘩𝘪𝘵𝘦𝘤𝘵
𝘈𝘞𝘚 𝘊𝘦𝘳𝘵𝘪𝘧𝘪𝘦𝘥 𝘋𝘦𝘷𝘦𝘭𝘰𝘱𝘦𝘳 𝘈𝘴𝘴𝘰𝘤𝘪𝘢𝘵𝘦
𝘈𝘞𝘚 𝘊𝘦𝘳𝘵𝘪𝘧𝘪𝘦𝘥 𝘎𝘦𝘯𝘈𝘐 𝘗𝘳𝘢𝘤𝘵𝘪𝘵𝘪𝘰𝘯𝘦𝘳
𝘈𝘞𝘚 𝘊𝘭𝘰𝘶𝘥 𝘛𝘦𝘤𝘩𝘯𝘰𝘭𝘰𝘨𝘺 𝘌𝘯𝘵𝘩𝘶𝘴𝘪𝘢𝘴𝘵

Kiro Did It! : How Kiro Helped Me Modernize My Portfolio Website!

Girish Bhatia — Thu, 11 Dec 2025 03:58:27 +0000

Hi! I’m Girish, an AWS Community Builder and Cloud Tech Enthusiast, with expertise in delivering customer-focused and business-impacting cloud transformation programs of high complexity.

In my previous article, I shared how I used AWS Kiro’s vibe coding feature to build a Customer Lookup API powered by API Gateway, Lambda, DynamoDB, and AWS SAM.

This time, I wanted to take on something more personal, updating my portfolio website. And once again, Kiro became my co-developer for the job.

What Did I Build and Why?

A few years ago, I built my personal portfolio website using AWS services such as S3, CloudFront, ACM, and Route 53. It worked great for hosting and showcasing my work, but the navigation always felt like an area that could be improved, more animated, more responsive, and more user-friendly.

Between managing large-scale cloud initiatives and exploring new AWS features, I never got the time to redesign it. But with Kiro and Generative AI in my toolkit this year, I finally decided to revisit the site and bring it up to modern design standards.

My goal was simple, make the navigation intuitive, engaging, and mobile-friendly, while experimenting with how far AI-assisted coding could go in enhancing a static site’s front-end.

This wasn’t just a design refresh, it was an opportunity to see how Kiro’s AI-driven coding capabilities could help me test, modify, and visualize design ideas in real time.

How Kiro and I Did It!

I started by asking Kiro a few questions, such as:

“Can I run my portfolio site in Kiro before hosting it on AWS, so I can make and preview changes locally?”

Once Kiro helped me run the static site locally, I moved on to the main goal: upgrading the navigation. I asked Kiro to provide multiple design options and then review the site’s mobile responsiveness, ensuring it looked great across iPhone, iPad, and other devices.

Before & After: Website Upgrade

Old Navigation

Here’s how the navigation on my portfolio website looked before the update. It was functional but static and plain, with minimal visual cues and limited interactivity. Scrolling and mobile responsiveness were also basic, leaving room for improvement.

New Navigation

After Kiro helped me transform the website, the navigation is now modern, interactive, and visually engaging. It features smooth animations, clear section highlighting, and improved mobile responsiveness, making it easier and more enjoyable to navigate. The overall look feels fresh, professional, and aligned with a contemporary portfolio design.

Kiro in Action

Prompt 1 – Preview the Site Locally

“How can I run this static website in Kiro to preview?”

Kiro response:

Prompt 2 – Update the Navigation

“I would like to update the profile.html to include navigation for Home, About Me, etc.”

Kiro response:

Prompt 3 – Color and Icon Enhancements

“Can you keep the orange color for the icons but change the blue to better match the page background?”

Kiro response:

Prompt 4 – Add My AWS Community Builder Badge

Finally, I asked Kiro to add my AWS Community Builder image, and it placed it perfectly!

Kiro’s Feedback Loop

One of the powerful features of Kiro is its feedback loop, which keeps you informed about every change it makes. After implementing the updates, Kiro summarized the enhancements in detail, explaining what was modified and why. This helped me understand how each visual tweak, animation, or layout adjustment contributed to a better user experience. It felt almost like having a co-developer reviewing and guiding the improvements in real time.

🎯 Navigation Enhancements Made

Visual Improvements

Fixed header bar with gradient background and blur effect
Icons for each section (Home, About, Projects, etc.)
Hover animations
Active section highlighting with animation
Clear separation between main navigation and external links

User Experience

Smooth scrolling between sections
Active section tracking while scrolling
Better mobile responsiveness with vertical stacking
Improved accessibility with focus and hover states

Technical Features

Glass-morphism style with backdrop blur
Dynamic background opacity on scroll
Proper scroll offset handling for fixed navigation
Enhanced CSS transitions and transforms

The result? A modern, professional, and responsive navigation that feels alive, stays visible as you scroll, and clearly indicates your current section.

Key Takeaways

This upgrade experience with Kiro taught me several important lessons:

Kiro accelerates development — it makes quick design and UI improvements easier without heavy manual coding.
Local previewing through Kiro allows safe experimentation before deployment to AWS.
Generative AI guidance helps refine color schemes, layout, and responsiveness interactively, making design iterations faster and more precise.
Kiro’s feedback loop keeps you in control, summarizing updates clearly and ensuring transparency throughout the process.

Beyond these points, I realized how AI-assisted development can enhance creativity rather than replace it. By handling repetitive or technical tasks, Kiro lets you focus on design, user experience, and experimentation, bridging the best of automation and human creativity. I combined it with AWS Services to create a finished product!

Conclusion

In this article, I demonstrated how Kiro can accelerate development, save time and allow you to focus on end goal as oppose to spending hours adjusting layouts, colors, and animations manually, Kiro helped me prototype, iterate, and visualize changes instantly.

The real magic was in the feedback loop. Kiro not only implemented updates but also explained what was changed and why, almost like a coding partner guiding each improvement.

Upgrading my portfolio website turned out to be more than just a design refresh. It became a practical demonstration of how Kiro and Generative AI can accelerate front-end development while keeping creativity at the center.

Whether you’re upgrading a static site, fine-tuning navigation, or experimenting with interactive elements, Kiro’s blend of AI-assisted coding and automation makes it easier than ever to transform ideas into working result fast, accurate, and visually stunning.

Generative AI isn’t replacing creativity, it’s enhancing it And with Kiro, even small weekend projects like a portfolio update can feel like working with a full design and development team by your side.

Generative AI is transforming the way code is built, and tools like Kiro make the process even easier. While debugging can become more challenging as more code is generated with GenAI, Kiro’s features such as spec-driven development and design documentation generation can help address these challenges.

I believe this is just the beginning, and these tools will continue to evolve rapidly!

Thanks for reading, and I hope you found this insightful.

Watch the video here:

𝒢𝒾𝓇𝒾𝓈𝒽 ℬ𝒽𝒶𝓉𝒾𝒶
𝘈𝘞𝘚 𝘊𝘦𝘳𝘵𝘪𝘧𝘪𝘦𝘥 𝘚𝘰𝘭𝘶𝘵𝘪𝘰𝘯 𝘈𝘳𝘤𝘩𝘪𝘵𝘦𝘤𝘵
𝘈𝘞𝘚 𝘊𝘦𝘳𝘵𝘪𝘧𝘪𝘦𝘥 𝘋𝘦𝘷𝘦𝘭𝘰𝘱𝘦𝘳 𝘈𝘴𝘴𝘰𝘤𝘪𝘢𝘵𝘦
𝘈𝘞𝘚 𝘊𝘦𝘳𝘵𝘪𝘧𝘪𝘦𝘥 𝘎𝘦𝘯𝘈𝘐 𝘗𝘳𝘢𝘤𝘵𝘪𝘵𝘪𝘰𝘯𝘦𝘳

Kiro Did It: Kiro Goes GA - And Replaces My Favorite CLI!

Girish Bhatia — Wed, 19 Nov 2025 04:25:24 +0000

Kiro Goes GA - And It Just Replaced My Favorite CLI!

AWS announced the General Availability of Kiro on 11/17/25, and the update included several new features that immediately caught my attention. I have already appreciated Kiro for its vibe coding, specs-driven development approach, MCP integrations, and hooks. However, the most notable change for me was the introduction of the Kiro CLI and its seamless integration with the Kiro IDE.

I had originally planned to explore the Kiro CLI over the upcoming weekend… but little did I know my exploration would take a surprising turn.

Goodbye Q CLI, Hello Kiro CLI!

While checking the documentation, I discovered something unexpected:

Kiro CLI has officially replaced the Amazon Q Developer CLI

In other words :

one of my favorite dev tool CLIs got replaced by… another one of my favorite dev tool CLIs! 😄

Upgrading to Kiro CLI Took One Command

If you're already logged into the Q CLI, the upgrade path is literally a single command:

q update

Running this instantly upgraded my environment from Q CLI → Kiro CLI.

Here’s the message I received after the upgrade:

The transition was seamless, and all my existing workflows including MCP configurations immediately recognized the new CLI.

Quick Session With Kiro CLI

I couldn’t resist trying it out immediately.

To keep things simple, I asked Kiro CLI to do a quick cost projection for a hypothetical single-page website hosted on an EC2 instance, expecting around 10,000 hits per month.

What I Asked

Response I Received

Even for a lightweight scenario like this, the response Kiro generated was clean, structured, and extremely quick showcasing just how interactive and developer-friendly this CLI experience is.

Conclusion

It’s exciting to see how these GenAI-driven tools continue to evolve. With the launch of Kiro GA and the introduction of the Kiro CLI, AWS is clearly doubling down on making the entire development workflow conversational, intelligent, and frictionless.

Tools like Kiro aren’t just enhancing productivity, they’re transforming how we think about software development.

I can’t wait to see what additional surprises AWS brings to re:Invent 2025, especially in the Kiro ecosystem.

Stay tuned, I’ll be exploring more of the Kiro CLI capabilities in my upcoming articles!

Thanks for reading, and I hope you found this insightful.

Kiro Did It: Streamlining Comments, Structure, and Logging Using Steering Docs!

Girish Bhatia — Sat, 15 Nov 2025 22:18:10 +0000

Hi! I’m Girish, an AWS Community Builder and Cloud Tech Enthusiast, with expertise in delivering customer-focused and business-impacting cloud transformation programs of high complexity.

In my previous article, I shared how I used AWS Kiro’s vibe coding feature to build a Customer Lookup API powered by API Gateway, Lambda, DynamoDB, and AWS SAM.

In another article, I also talked about Kiro's hooks using a simple HelloWorld Python program. I explained how hooks can automatically update a README.md file whenever the Python code is modified.

Unlike traditional IDEs, Kiro is a GenAI-enabled IDE that supports both specs-driven development and vibe coding.

In addition to specs, vibe coding and Hooks, Steering Docs is another powerful feature that helps developers by streamlining Comments, Structure, and Logging in your code.

In this article, I will explore how Kiro's steering doc feature works using a simple HelloWorld Python program. I’ll show how steering docs can help guide the code generation using the product definition, structure and tech stack defined in the steering docs.

What Did I Build and Why?

I wanted to demonstrate how Kiro Steering docs are another value-added feature of this GenAI-enabled IDE. Steering docs can provide guidance when generating code by defining product, code structure and tech stack upfront.

When you add steering docs, Kiro adds three docs product.md, structure.md and tech.md. These files contain the guidelines that Kiro uses when generating the code.

I created a hello world document and added steering docs.

The goal wasn’t to build production-ready code right away, but to use a simple function to demonstrate how Kiro Steering Docs is another feature that can help developer increase the productivity and accelerate software development.

Architecture/Design

Before diving in, let’s review the diagram to understand how these components interact.

What Are Steering Docs in Kiro IDE?

The Kiro Steering Docs are a key feature that helps Kiro understand what guidance to follow when generating code. By specifying the desired product goals, tech stack, and code structure, these guidelines allow Kiro to automatically implement best practices upfront. This ensures the resulting code consistently follows standards for comments, logging, and structure, yielding clean, safe, and maintainable code without manual intervention.

To generate the steering docs, you click on Kiro icon and then generate Steering Docs.

Kiro will scan your project file and will generate the Steering Docs.

Kiro will generate 3 files as Steering Docs:

Product.md
Structure.md
Tech.md

Let's see what each of these file contains:

product.md

Provides a high-level overview of what the HelloWorld service does, why it exists, and the core behavior users should expect.

tech.md

Lists the technology stack, tools, and essential commands required to run, test, and deploy the HelloWorld service.

structure.md

Describes the project’s folder layout and explains the organizational principles applied to keep the code clean and maintainable.

Review the Steering Docs

Once the Steering Docs have been generated, you would see these 3 files in your project view.

Review product.md

You’ll see that:

The product.md contains section to describe the product purpose, key features and target users.

I will update product.md to add detail about HelloWorld project. Updated file will look similar to below:

Review tech.md

You’ll see that:

The tech.md contains section to describe the tech stack like what language to use, logging, run time, testing and more.

Review structure.md

You’ll see that:

The structure.md contains section to describe the structure and organization of the code directory.

With Kiro, you can further refine your steering docs as well. Once you click on 'Refine', Kiro will refine the steering docs.

Kiro Code Generation

Now that I have steering docs in place, I will ask Kiro to generate the hello world function. Below is the prompt, I provided:

Kiro responded by confirming that it will generate the asked code.

Review Generated Code

Generated code for python function.

Generated code for lambda handler.

Test the function

I can validate the generated function using the Python command as below:

Since Steering docs in place, if I add a new function, Kiro will follow the guidance from these steering docs to follow the same pattern.

I added another function as below and as you can see, this one uses comments and logging based on the guidance noted in the steering docs.

Conclusion

In this article, I demonstrated how Kiro can accelerate development by applying Steering Docs directly into the workflow, guiding code generation toward consistent structure, clear documentation, proper logging, and reliable exception handling. This shifts effort away from repetitive cleanup and review, allowing developers to focus on higher-value logic and design.

Whether you’re defining code comments, enforcing Python structure, standardizing logging practices, or ensuring proper error handling, Steering Docs act as your silent co-developer by shaping every output to match your standards.

By starting with small, practical examples and gradually expanding your Steering Docs, you can establish a development environment where every code change automatically aligns with best practices and maintains consistent quality.

Experiment with these Steering Docs and see how Kiro transforms your everyday coding experience.

I believe this is just the beginning, and these tools will continue to evolve rapidly!

Thanks for reading, and I hope you found this insightful.

Watch the video here:

Let Kiro Do the Work: Automate Your Code and Documentation with Hooks!

Girish Bhatia — Sun, 02 Nov 2025 19:37:23 +0000

Hi! I’m Girish, an AWS Community Builder and Cloud Tech Enthusiast, with expertise in delivering customer-focused and business-impacting cloud transformation programs of high complexity.

In my previous article, I shared how I used AWS Kiro’s vibe coding feature to build a Customer Lookup API powered by API Gateway, Lambda, DynamoDB, and AWS SAM.

Unlike traditional IDEs, Kiro is a GenAI-enabled IDE that supports both specs-driven development and vibe coding.

In addition to specs and vibe coding, Hooks are another powerful feature that automate repetitive tasks. This feature saves developers valuable time and allows them to focus more on the functional aspects of software development.

When working on rapid application development, automating repetitive tasks can save significant time and reduce errors. Kiro IDE, known for accelerating full-stack app development with AI-powered code generation, also supports the Hook feature, a powerful way to trigger automatic actions whenever your code changes.

In this article, we’ll explore how Kiro’s Hook feature works using a simple HelloWorld Python program. We’ll show how hooks can automatically update a README.md file whenever the Python code is modified.

I’ll then add another hook that not only creates or updates the README.md file but also runs Bandit, an open-source tool that scans Python code for common security vulnerabilities such as hardcoded passwords.

What Did I Build and Why?

I wanted to demonstrate how Kiro hooks are another value-added feature of this GenAI-enabled IDE. Hooks can automate repetitive tasks such as updating documentation or scanning code for security vulnerabilities.

Here are the two hooks I created:

Hook#1

Documentation update

Instructions for Kiro agent

The Python source files have been modified. Please review the changes and update the documentation accordingly. If there is a README.md file, update it to reflect any new functionality, API changes, or usage examples. If there is a /docs folder, update the relevant documentation files there. Focus on keeping the documentation accurate and up-to-date with the current codebase.

Hook#2

Documentation update and python code security scan using bandit

Instructions for Kiro agent

A Python file has been modified. Please: 1) Run bandit security scanning on all *.py files in the current directory and output the results in JSON format. bandit is installed in the virtual environment, and 2) Update the README.md file to reflect any changes or new information about the Python files in the project.
The goal wasn’t to build production-ready code right away, but to use a simple function to demonstrate how Kiro hooks can automate repetitive tasks allowing developers to invest their time in building business logic instead of routine maintenance.

Architecture/Design

Before diving in, let’s review the diagram to understand how these components interact.

What Are Hooks in Kiro IDE?

Hooks in Kiro IDE are automated triggers that run specific actions when defined events occur such as when a file is created, saved, or deleted. Hooks can also be invoked manually.

You can use hooks to:

Update documentation automatically
Regenerate API specs when endpoints change
Generate commit messages or summaries based on updated code
Run code scans when code is added or updated

Hooks bring automation directly into your development environment, making workflows smarter and faster without relying on external scripts. They save time by letting the AI agent handle repetitive tasks while developers focus on innovation and quality.

Review the Steps

Hook#1

Create a HelloWorld Function

Save the file

Saving the file will trigger the manual and you should see that a readme file has been created.

This is a simple example of how Kiro Hook took care of creating the readme file based on the function code. If you update the code further, then Kiro will update the readme document to align with the code.

Hook#2

Update the function code to add a parameter so that it takes the name and then print the message.

Also add a variable to store a hardcoded password. This update is required so that when hook is triggered, it finds a security vulnerability like hardcoded password.

Saving the file will trigger the manual and you should see that a readme file has been updated. Also, you will see a code scanning results informing you of a security vulnerability in the code due to hardcoded password.

Review readme file
You’ll see that:

The README.md file now reflects the updated function definition with the new name parameter.

The file also includes the security scan results generated by Bandit.
Not only has the README file been updated, but the security scan has also been executed , showcasing Kiro’s ability to perform multiple automated tasks.

Not only readme file has been updated, security scan has also been completed.

Conclusion

In this article, I demonstrated how Kiro can accelerate development by bringing automation directly into the development workflow, allowing developers to focus more on creativity and logic rather than repetitive maintenance tasks.

Whether you’re updating documentation, generating commit messages, formatting code, or scanning code, hooks act as your silent co-developer, working in partnership.

By starting with small, practical examples and gradually combining them, you can create a fully automated environment where every code change triggers meaningful actions.

Experiment with these hook ideas and see how Kiro transforms your everyday coding experience.

I believe this is just the beginning, and these tools will continue to evolve rapidly!

Thanks for reading, and I hope you found this insightful.

Watch the video here:

Kiro Did It! – From Prompt to Customer API & UI Using Vibe Coding!

Girish Bhatia — Fri, 17 Oct 2025 19:39:29 +0000

Hi! I’m Girish, an AWS Community Builder, Cloud Tech Enthusiast, with expertise in delivering customer-focused and business-impacting cloud transformation programs of high complexity.

In this article, I’ll share how I used AWS Kiro’s vibe coding feature to build a Customer Lookup API powered by API Gateway, Lambda, DynamoDB, and AWS SAM.

Unlike traditional IDEs, vibe coding in Kiro lets you code in flow with lightweight prompts—no need to over-specify requirements up front. It’s perfect for experimenting, prototyping, and just “vibing” with code.

Instead of manually wiring services together, I simply gave Kiro a natural-language prompt, and within minutes I had a working, deployable prototype. That’s the magic of vibe coding!

What did I build and why?

I wanted to create a quick Customer Lookup full-stack application to demonstrate how fast you can go from an idea to a working solution using Kiro’s vibe coding feature. Instead of manually setting up AWS resources, I described my requirements in plain English, and Kiro generated the entire project for me including the backend APIs and the UI.

Here’s what I ended up with:

A REST API hosted on API Gateway
GET /customers – List all customers
GET /customers/{custId} – Retrieve a specific customer
POST /customers – Create a new customer
PUT /customers/{custId} – Update an existing customer
DELETE /customers/{custId} – Delete a customer
A Lambda function for handling API requests
A DynamoDB table to store customer data (custId, Name, State, Zipcode)
A UI hosted on EC2, integrated with these API endpoints for CRUD operations
An AWS SAM template for building and deploying the stack
Sample JSON events for testing

The goal wasn’t to build production-ready code right away, but to quickly get a working full-stack prototype that can later be extended with authentication, observability, monitoring, and performance tuning.

Architecture Overview

Here’s a quick look at how the components work together:

Review Steps: From Prompt to Prototype

Start a Vibe Coding Session

Open Kiro, switch to vibe coding mode, and simply type a natural prompt like:

"Build a customer lookup api as rest api. api will be hosted using aws gateway, integrated with a lambda function, data will be stored in a DynamoDB table, create a simple table to store this data with four fields - custId, Name, state, zipcode. do not create test framework as need to get a quick working prototype first before adding testing and performance framework. I would like to use AWS SAM to build and deploy this solution."

Kiro responded to me with below answer:

Kiro Generates the Project files

In minutes, Kiro produced:

A SAM template (template.yaml)
A Lambda function (app.py)
A DynamoDB table definition
Sample JSON Events to test the API with

Example SAM template (simplified):

Review the Lambda Function

Kiro generated a Python handler with DynamoDB integration:

Review Sample JSON Event

Build & Deploy with SAM

Once I reviewed the files, it was just a matter of building and deploying.

Use the following command to build the function:
Command: sam build

You can deploy it to the AWS Cloud using the sam deploy command:
Command: sam deploy

SAM packaged and deployed the API Gateway, Lambda, and DynamoDB resources in my AWS account.

Review using AWS Console

Since the resources have been deployed in my AWS account, I logged in to the AWS Management Console to verify them.Here’s what I checked:

API Gateway – Confirmed the REST API with all CRUD endpoints (GET, POST, PUT, DELETE).
Lambda Function – Validated that the function was created and linked to API Gateway.
DynamoDB Table – Verified the customers table with attributes (custId, Name, State, Zipcode).
CloudFormation / SAM Stack – Ensured the stack deployed successfully with all resources.

Test the API

Now that I have the API endpoint, I will use the Postman to invoke the API and will review the response returned.

This is a CRUD API, so it supports other operations as well. For this demonstration, however, I focused on POST and GETrequests, to create a record and fetch a record through the API endpoint.

Adding a Functional UI with Kiro

Since the CRUD API worked as expected, I asked Kiro to create a UI integrated with these API endpoints, and here is the functional UI it generated!

I manually added API security features so that if a valid subscription key is not passed to API Gateway, an error is shown:

🔒 Invalid key → access denied
✅ Valid key → response returned successfully

And here is how the UI looks when a response is returned by the API endpoints!

After validating that all functions were working as expected, I asked Kiro to update the UI by replacing the CRUD function dropdown with radio buttons to make it more user-friendly. Screenshots below:

Multiple API endpoints + a working UI in under 30 minutes — all powered by GenAI and Kiro!

But does that mean expertise isn’t required? Not at all.

I still:

Validated the solution
Deployed it using SAM
Configured API security with subscription keys, quotas, and client application invocations

It felt like a team effort where Kiro acted as a peer—helping me generate, review, and collaborate to get the prototype built quickly.

Conclusion

In this article, I demonstrated how Kiro can accelerate development by enabling the creation of a fully functional CRUD Customer Lookup REST API with DynamoDB and extending it into a complete full-stack application with a working UI, all in a fraction of the usual time. While it may not be production-ready, it effectively serves the purpose of creating a quick, reviewable prototype for business and technical stakeholders.

Kiro not only generated the backend API and application code but also produced an AWS SAM template and a front-end UI prototype, completing the full-stack build seamlessly.

I believe this is just the beginning, and these tools will continue to evolve rapidly!

Thanks for reading, and I hope you found this insightful.

Watch the video here:

AWS re:Invent 2025: 2000+ Sessions, 5 Days, One You!

Girish Bhatia — Sun, 05 Oct 2025 00:10:43 +0000

Hi! I'm Girish, an AWS Community Builder and Cloud Tech Enthusiast with expertise in delivering customer-focused and business-impacting cloud transformation programs of high complexity.

In this article, I'll share insights about re:Invent and the many different opportunities it offers for learning!

If you’re headed to AWS re:Invent, you already know it’s not just a conference—it’s an experience.

With 2,000+ sessions spread across 5 days, it can feel overwhelming to decide where to spend your time. Add in the fact that there isn’t just one type of session, but more than 11 different formats from breakout sessions to chalk talks, bootcamps, lightning talks, and more and the challenge becomes real.

So how do you know which sessions to attend?

Well… truthfully, you don’t get to attend everything 😊.

But you can narrow things down by aligning sessions with your interests and objectives.

Whether you’re into Serverless, Generative AI, Containers, Security, or Industry-focused tracks, a bit of planning goes a long way.
Let’s take a look at a few of the key session types, what they mean, and how much time they usually take:

Keynotes & Leadership Sessions

Typically 4-5 keynote one scheduled for each day. Plan 60-120 mins.
Keynotes feature AWS leaders unveiling new services and the vision for the future of cloud.
Don't miss Dr. Werner Vogels' keynote!

Breakout Sessions

Typically 45-60 mins duration.
Traditional conference talks with slides and demos.
Great for structured learning.
Plan ahead for these!

Chalk Talks

Typically 60 mins duration.
Interactive whiteboard-style discussions with AWS experts.
Short presentation, then deep Q&A and design discussions.

Workshops

Typically 120 mins duration.
Hands-on sessions where you build with AWS services in real time.
You need to pre-register for these.
Need to bring your laptop.

Builders’ Sessions

Typically 60 mins duration.
Small group, 5-6 people
Hands on building.

Bootcamps

Full day session, typically 6-8 hours
These are paid sessions. Plan ahead
Good if you want dedicated time to skill up in a specific area.
Instructor Led.

In addition to these, there are also lightning talk and self paced labs as well.

How I’m Planning My re:Invent 2025 Sessions

My current role requires a deep understanding of AWS Cloud services as well as the compliance needs of highly regulated financial and banking environments. Since my work doesn’t involve hands-on coding, I plan to skip most Builders’ Sessions and Workshops and instead maximize my time exploring new services and upcoming enhancements. The goal is to bring back practical insights that I can apply to the cloud transformation initiatives I’m currently leading.

This year, I’m focusing on four key themes:

Serverless
Generative AI
Security & Compliance
Observability

I’ve shortlisted around 60 sessions that align with these themes. Of course, I know it’s not realistic to attend them all. With time spent walking between venues, networking, making new friends, and connecting with fellow AWS Community Builders, I’m realistically targeting 20–25 sessions for the week. I’ll refine my list further once I have more details about session timings and venues.

This short list should allow me switching to a different session If a reserved session is full or plans change. This approach helps me maximize learning while keeping the experience enjoyable and stress-free.

Planning Tips

Select your theme and select desired sessions from the event catalog
Shortlist more sessions than you can attend to plan the backup but don't select everything.
Plan for walking, networking, and fun time.
Don’t panic if you miss a session. Many are recorded and available on-demand after the event!

Final Thoughts

You won’t be able to experience everything at AWS re:Invent, and that’s perfectly okay. The key is to focus on your learning goals, build a thoughtful schedule, and leave room for spontaneous opportunities. Stay organized, keep an open mind, and make re:Invent a memorable and inspiring experience.

See you at re:Invent 2025!!!

Kiro Did It! – From Prompt to Customer API Using Vibe Coding!

Girish Bhatia — Sun, 21 Sep 2025 06:05:02 +0000

Hi! I’m Girish, an AWS Community Builder and Cloud Tech Enthusiast. In this article, I’ll share how I used AWS Kiro’s vibe coding feature to build a Customer Lookup API powered by API Gateway, Lambda, DynamoDB, and AWS SAM.

Instead of manually wiring services together, I simply gave Kiro a natural-language prompt describing what I wanted, and within minutes I had a working, deployable prototype. That’s the magic of vibe coding!

What did I build and why?

I wanted to create a quick Customer Lookup API to demonstrate how fast you can go from an idea to a working solution using Kiro’s vibe coding feature. Instead of manually setting up AWS resources, I described my requirements in plain English, and Kiro generated the project for me.

Here’s what I ended up with:

A REST API hosted on API Gateway
This API supports CRUD operations:
GET /customers – List all customers
GET /customers/{custId} – Retrieve a specific customer
POST /customers – Create a new customer
PUT /customers/{custId} – Update an existing customer
DELETE /customers/{custId} – Delete a customer
A Lambda function for handling requests
A DynamoDB table to store customer data (custId, Name, State, Zipcode)
An AWS SAM template for building and deploying the entire stack
Sample JSON events can be used to test the API.

The goal wasn’t to build a production-ready API right away, but to get a working prototype fast, something I can extend later with authentication, observability, monitoring, and performance tuning.

Architecture Overview

Here’s a quick look at how the components work together:

Review Steps: From Prompt to Prototype

Step 1: Start a Vibe Coding Session

Open Kiro, switch to vibe coding mode, and simply type a natural prompt like:

"Build a customer lookup api as rest api. api will be hosted using aws gateway, integrated with a lambda function, data will be stored in a DynamoDB table, create a simple table to store this data with four fields - custId, Name, state, zipcode. do not create test framework as need to get a quick working prototype first before adding testing and performance framework. I would like to use AWS SAM to build and deploy this solution."

Kiro responded to me with below answer:

Step 2: Kiro Generates the Project files

In seconds, Kiro produced:

A SAM template (template.yaml)
A Lambda function (app.py)
A DynamoDB table definition
Sample JSON Events to test the API with

Example SAM template (simplified):

Step 3: Review the Lambda Function

Kiro generated a Python handler with DynamoDB integration:

Review Sample JSON Event

Step 4: Build & Deploy with SAM

Once I reviewed the files, it was just a matter of building and deploying.

Use the following command to build the function:

Command: sam build

You can deploy it to the AWS Cloud using the sam deploy command:

Command: sam deploy

Change Set

SAM packaged and deployed the API Gateway, Lambda, and DynamoDB resources in my AWS account.

Review using AWS Console

Since the resources have been deployed in my AWS account, I logged in to the AWS Management Console to verify them.

Here’s what I checked:

API Gateway – Confirmed the REST API with all CRUD endpoints (GET, POST, PUT, DELETE).
Lambda Function – Validated that the function was created and linked to API Gateway.
DynamoDB Table – Verified the customers table with attributes (custId, Name, State, Zipcode).
CloudFormation / SAM Stack – Ensured the stack deployed successfully with all resources.

Step 5: Test the API

Now that I have the API endpoint, I will use the Postman to invoke the API and will review the response returned.

However before I invoke a GET request, I will use the command line to POST a record via API that will be stored in the DynamoDB CustomerTable.

Command: curl -X POST https://21374mswxh.execute-api.us-east-2.amazonaws.com/prod/customers \
-H "Content-Type: application/json" \
-d '{"custId":"CUST001", "name":"Girish", "state":"NY", "zipcode":"10001"}'

I will now invoke GET on this API endpoint using Postman. This should return the record that I added to the database.

This is a CRUD API, so it supports other operations as well. For this demonstration, however, I focused on POST and GETrequests, to create a record and fetch a record through the API endpoint.

Cleaning Up Resources

To avoid charges, don’t forget to clean up:

Since these resources were build and deployed using AWS SAM, these can be deleted using AWS SAM command.

Command: sam delete

Conclusion

In this article, I demonstrated how Kiro made it effortless to create a fully functional CRUD Customer Lookup REST APIintegrated with a database, using vibe coding to quickly build a working prototype.

Not only was the API generated, but an AWS SAM template was also created to support create, update, destroy, and recreate scenarios with Infrastructure as Code.

I believe this is just the beginning, and these tools will continue to evolve rapidly!

I hope you found this helpful and informative.

Thank you for reading!

Watch the video here: