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

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.

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:

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