Forem: amarpreetbhatia

Building a Windows Productivity Tool Using GitHub Copilot CLI

amarpreetbhatia — Mon, 09 Feb 2026 08:56:19 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

I built a small productivity tool called PowerShell Helper.

While working on Windows, I often switch between Bash-enabled terminals and PowerShell. I keep missing the common Bash commands that I use daily, and I usually end up either installing Bash, Googling the PowerShell equivalent, or asking an AI tool questions like:

“How do I curl a URL in PowerShell?”

This constant context switching breaks flow.

So I built PowerShell Helper — a lightweight CLI tool that lets me describe what I want in plain English and instantly get the correct PowerShell command along with a simple explanation.

It’s a small tool, but it solves a real daily pain point for me.

Demo

GitHub repository:

https://github.com/amarpreetbhatia/powershell-helper

The tool runs directly from the command prompt or PowerShell.

Example usage:

Convert a natural language task into a PowerShell command
See a short explanation so you actually learn the command instead of just copying it

My Experience with GitHub Copilot CLI

This was the most impressive part of the project.

I built this entire tool in about 15 minutes, without opening any IDE.

Everything was done using a simple command prompt and GitHub Copilot CLI.

Copilot CLI helped me:

Generate the initial PowerShell script structure
Refine the command output to be clear and beginner-friendly
Add small safety and usability improvements
Quickly draft documentation without overthinking it

What I really liked is how Copilot CLI fits naturally into the terminal workflow. Instead of switching between editor, browser, and AI chat, I stayed in the CLI the whole time.

This project showed me how Copilot CLI isn’t just for writing code — it’s a powerful way to think, build, and ship small productivity tools very quickly.

From Vibe Coding to Spec-Driven Development that Slashed Dev Time

amarpreetbhatia — Tue, 02 Dec 2025 11:16:54 +0000

🚀 From 'Vibe' to Victory: How Spec-Driven Development in Kiro IDE Slashed My Dev Time by 44%

A deep dive into building a full-featured Agile Planning app with zero WebSocket bugs.

When I first used Kiro a few months ago, I was focused entirely on vibe coding. It was fun, but chaotic. Now, after experimenting with spec-driven development (SDD), I'm completely blown away! I strongly suspect Kiro pioneered this structured approach, which was then adopted by other coding agents.

This time, I built a full-featured Agile Planning application with real-time collaboration, GitHub integration, and a collaborative whiteboard. The result?

Complex features like authentication, WebSocket management, and drag-and-drop became surprisingly straightforward.

Here's exactly why the structured "Plan, Review, Execute" model beats "vibe coding" every single time, backed by concrete numbers from the project.

🤯 The Two Worlds of Coding

What is "Vibe Coding"?

You know the drill:

Open your editor.
Start typing code.
"I'll figure it out as I go."
Realize you forgot crucial edge cases.
Refactor everything (or leave it messy).
Repeat.

It feels productive, but it's chaos in disguise. It's building a skyscraper without a blueprint.

Enter: Spec-Driven Development (SDD)

SDD follows a rigorous, structured approach built directly into the Kiro IDE:

Plan: Write detailed requirements and acceptance criteria.
Review: Create a comprehensive design document (architecture, data models, properties).
Execute: Implement with clear tasks and continuous validation against the spec.

I used Kiro IDE, which has built-in support for this workflow, and the difference was night and day.

🎯 The Project: Agile Planning Tool

I built a real-time collaborative planning poker application.

View the Code: Agile Planning Tool on GitHub

Core Features Implemented	Tech Stack
Real-time Planning Poker	Next.js 14 (App Router)
GitHub OAuth Authentication	TypeScript
WebSocket Collaboration	MongoDB + Mongoose
Drag-and-drop Story Management	Socket.IO
Collaborative Whiteboard	Playwright (E2E Tests)
External Tool Embedding (Miro, Figma)	Shadcn UI

💡 1. Why Spec-Driven Development Won: Complex Features Became Simple

SDD forces you to think through the entire system before writing the first line of code.

A. Authentication (GitHub OAuth)

Vibe Coding	Spec-Driven Development
Approach: "I'll just add GitHub login... wait, how do I handle tokens? What about session management? Encryption?"	Approach: The spec demands defining security up front.
Result: 2 days of debugging and insecure token handling.	Result: Implementation took 2 hours instead of 2 days of debugging.

Key Requirement: Authentication

Acceptance Criteria:
3. THE System SHALL store encrypted access tokens in the database.

B. Real-Time Collaboration

Vibe Coding	Spec-Driven Development
Approach: "Let's add Socket.IO... oh wait, how do I handle disconnections? What about race conditions?"	Approach: The spec forces planning for high-availability.
Result: Production bugs related to race conditions and dropped connections.	Result: Zero production bugs related to WebSocket management.

Key Requirement: Real-Time Updates

Acceptance Criteria:
3. WHEN connection drops, THE System SHALL attempt reconnection with exponential backoff.

C. Drag-and-Drop Story Management

Vibe Coding	Spec-Driven Development
Approach: "I'll use a library... which one? How do I persist order? What about conflicts?"	Approach: The spec explicitly defines conflict resolution.
Result: Janky UX and data integrity issues upon concurrent edits.	Result: Smooth drag-and-drop with zero conflicts.

Key Requirement: Story Backlog

Acceptance Criteria:
4. THE System SHALL handle concurrent reordering conflicts gracefully.

📊 2. The Numbers: A Quantitative Victory

The biggest win was the dramatic reduction in debugging and refactoring time. Upfront planning saves time, period.

Development Time Comparison

Approach	Planning	Coding	Debugging	Refactoring	Total
Vibe Coding	0h	40h	30h	20h	90h
Spec-Driven	7h	35h	5h	3h	50h
Time Saved					40 hours (44%)

Code Quality Metrics

Metric	Vibe Coding (Hypothetical)	Spec-Driven (Actual Project)
Production Bugs	15+	2
Major Refactors Needed	5 major	0 major
Test Coverage	40%	85%
Documentation	Sparse and outdated	Comprehensive (The Spec IS the documentation)

✍️ 3. Testing Became Natural

Because every major feature had pre-written Acceptance Criteria (AC), writing E2E tests was a mere translation process.

An AC like: “WHEN GitHub OAuth succeeds, THE System SHALL create a user session with GitHub profile data.” directly translates into a test block.

test('should complete full estimation workflow', async ({ page }) => {
  // Requirement 2.1: Create session
  await page.click('button:has-text("New Session")');

  // Requirement 6.3: Cast vote
  await page.click('[data-testid="poker-card-5"]');

  // Verify: Average calculated correctly
  await expect(page.locator('[data-testid="average"]'))
    .toContainText('5');
});

Result: 20+ E2E tests written with Playwright, providing high confidence and 100% passing smoke tests before deployment.

🛠️ Tools That Made It Possible

The built-in SDD support in Kiro IDE was the catalyst:

Structured Spec Creation: Used pre-built templates for requirements and design documents.
Requirement Linking: Ability to link code commits and tasks directly back to the specific requirement they fulfill.
Test Integration: Running tests directly from the spec view to validate acceptance criteria.

🛑 Common Objections Answered

Objection	Reality
"Specs take too long to write."	False: 7 hours of planning saved 40+ hours of debugging and rework. That's a huge ROI.
"Requirements change anyway."	False: Specs make changes easier. You know exactly which linked components need updating.
"This only works for big projects."	False: Even a quick, 30-minute spec for a small feature saves hours of rework and edge-case fixing.

✅ Final Thoughts

After building this project, I can't imagine going back to "vibe coding" for anything serious. The structure, clarity, and confidence that spec-driven development provides is invaluable.

Vibe coding feels fast but is ultimately slow.
Spec-driven development feels slow but is ultimately fast.

The Bottom Line: Give the "Plan, Review, Execute" model a try on your next project. Your future self will thank you for the robust architecture, reduced bug count, and the sheer predictability of development.

What's your experience with structured development approaches? Have you tried spec-driven development? Let me know in the comments!

#agile #typescript #testing #productivity #webdev #nextjs #react #mongodb #playwright #softwaredevelopment

From Idea to Production: Building a Secure Image Crawler with Kiro's AI-Powered Development

amarpreetbhatia — Fri, 29 Aug 2025 14:54:19 +0000

In Post, I like to share,
How I leveraged Kiro's spec-driven approach, agent hooks, and intelligent steering to build a full-stack web crawler in record time

Demo Link: https://www.youtube.com/watch?v=LMU6n6xW2IQ

🎯 The Challenge: Building Beyond "Vibe Coding"
We've all been there – starting a project with a vague idea, jumping straight into coding, and ending up with a tangled mess of half-implemented features. When I decided to build Image Collector, a secure web crawler for discovering and downloading website images, I knew I needed a different approach.

Enter Kiro – an agentic AI IDE that transforms how we build software from prototype to production. Instead of "vibe coding" my way through another project, I embraced Kiro's structured, spec-driven development approach.

🏗️ The Project: Image Collector
Before diving into my Kiro experience, let me introduce what we built:

Image Collector is a full-stack React application that ethically crawls websites to discover and display images in an interactive gallery. Think of it as a polite, intelligent web scraper that respects robots.txt, implements proper rate limiting, and provides secure bulk downloads.

Key Features:
🤖 Ethical Crawling: Respects robots.txt and nofollow directives
🎨 Interactive Gallery: Responsive carousel and grid views with full-screen preview
🔒 Secure Downloads: Background service worker with comprehensive security validation
📱 Modern UI: Material-UI dark theme with responsive design
⚡ Smart Discovery: Crawls main page plus one level of internal links (same domain only)
Source Code: https://github.com/amarpreetbhatia/imgcollector

🎪 My Favorite Kiro Features: The Game Changers

🎯 1. Steering - Project-Wide Intelligence
Kiro's steering files set standards for code generation including technology stack, project structure, and naming conventions. Here's how I used it:

Technology Stack Enforcement: Automatically ensured all components used TypeScript + Material-UI
Security Standards: Embedded security-first principles into every code generation
Architectural Consistency: Maintained clean separation between frontend/backend concerns

🪝 2. Agent Hooks - Automation That Actually Works
Hooks are user prompts triggered by file changes, enabling consistency and quality across development. My automated workflows:

Test Generation: Auto-created comprehensive test suites when saving React components
Documentation Updates: Automatically updated README and inline docs on architecture changes
Security Audits: Triggered security validation checks on service worker modifications

📋 3. Specs - From Chaos to Clarity
Kiro's structured specifications break down complex features into detailed implementation plans. This transformed my development:

Feature Breakdown: Complex crawling logic became manageable, tracked tasks
Progress Tracking: Real-time visibility into implementation progress
Quality Assurance: Built-in validation and testing requirements for each component
💬 Structuring Conversations with Kiro: The Art of AI Collaboration
The Initial Architecture Discussion
Instead of diving straight into code, I started with high-level architectural conversations:

Me: "I want to build a web crawler that can extract images from websites.
It needs to be ethical, secure, and have a modern UI. Can you help me
structure this as a full-stack application?"
Kiro: Generated comprehensive spec covering:

Client-server architecture to bypass CORS

Security considerations for web crawling

Progressive web app structure

Service worker architecture for downloads

The Most Impressive Code Generation
The Service Worker Security System was where Kiro truly shined. I described my security requirements in natural language:

Me: "I need a download system that can handle multiple images securely,
with file size limits, MIME type validation, and progress tracking.
It should work in the background without blocking the UI."
Kiro: Generated a complete 300+ line service worker with:

Semaphore-based concurrency control

Multi-layer security validation

Progress callback system

Automatic resource cleanup

Error handling and recovery

The generated code included sophisticated patterns I hadn't even thought of, like the semaphore implementation for download concurrency:

javascript
class Semaphore {
  constructor(maxConcurrency) {
    this.maxConcurrency = maxConcurrency;
    this.currentConcurrency = 0;
    this.queue = [];
  }

  async acquire(task) {
    // Intelligent queuing and execution logic
    // Auto-releases on completion
  }
}

Conversational Debugging Sessions
When I encountered CORS issues during development, our conversation looked like:

Me: "The frontend can't directly access external websites due to CORS.
How should I restructure this?"
Kiro: Immediately suggested:

Move crawling logic to Express backend

Use Cheerio for HTML parsing

Implement proper error boundaries

Add request timeout and retry logic

🪝 Agent Hooks: Automating My Development Workflow

Automated Test Generation Hook Created a hook that triggers whenever I save a React component:

yaml

.kiro/hooks/test-generator.md

trigger: file_change
pattern: "src/components/*.tsx"
prompt: |
Generate comprehensive tests for this component including:

Unit tests for all props and states
Integration tests for user interactions
Error boundary testing
Accessibility testing with React Testing Library Impact: Went from manually writing tests (often skipping them under time pressure) to having comprehensive test coverage automatically generated. My test coverage jumped from ~30% to 85%+.

Security Audit Hook Triggers on changes to security-critical files:

yaml

.kiro/hooks/security-audit.md

trigger: file_change

pattern: "public/download-worker.js|src/utils/securityConfig.ts"
prompt: |
Review this file for security vulnerabilities:

Input validation gaps
Injection attack vectors
Resource exhaustion risks
Data sanitization issues Create issues for any problems found. Impact: Caught potential security issues before they made it to production. Identified and fixed a resource exhaustion vulnerability in the download system.

Documentation Sync Hook Keeps documentation fresh with code changes:

yaml

.kiro/hooks/doc-sync.md

trigger: file_change
pattern: "src//*.ts|src//.tsx|server//.js"

prompt: |
Update relevant documentation for these code changes:

Update README if architecture changed
Update inline comments for complex functions
Update type definitions documentation Maintain consistent markdown formatting. Impact: Documentation stayed synchronized without manual effort. The comprehensive README you see was largely maintained through this hook.

📋 Spec-Driven Development: My Secret Weapon
Structuring the Master Spec
Instead of building features ad-hoc, I created a comprehensive spec that became my north star:

🚀 Development Workflow: The Kiro Advantage
Traditional Development vs. Kiro-Powered Development
Traditional Workflow:

Idea → Code → Debug → Refactor → Test → Deploy
Kiro-Powered Workflow:

Idea → Spec → Generate → Validate → Hook-Automation → Deploy
The Numbers Don't Lie

Application uses:

E-commerce Crawlers: Product image collection and analysis
Content Management: Automated image optimization and metadata extraction
SEO Analysis: Website visual content auditing
Design Research: Competitor visual analysis tools
AI Agent: Can connect the images to AI workflow to generate something new.

Check out the project: GitHub - Image Collector
https://github.com/amarpreetbhatia/imgcollector

Built with ❤️ using @kirodotdev spec-driven development. All code is open source and production-ready.

Tags: #AI #WebDevelopment #React #NodeJS #Security #Automation #Kiro #FullStack #WebCrawling #hookedonkiro

Built a Sudoku Game Using Amazon Q CLI on WSL Ubuntu – Try It Out!

amarpreetbhatia — Fri, 30 May 2025 15:10:10 +0000

I'm thrilled to share my experience building a browser-based Sudoku puzzle game using the new Amazon Q CLI – a powerful generative AI toolchain for developers. And yes, I did this using Windows WSL -d Ubuntu – making the process not only seamless but fun.

Check out the live game here:

🎮 Play Sudoku-Q now

GitHub Repo:

🔗 https://github.com/amarpreetbhatia/sudoku-q

🧠 Why Amazon Q CLI Blew My Mind (5 Cool Features)

As a seasoned developer, I’ve used many AI tools, but Amazon Q CLI truly stands out. Here are my top 5 features that made development a joy:

1. 🔄 Natural Language to Code Conversion

Just describe what you need and Q translates it into production-ready code. This enabled me to scaffold game logic, UI components, and helper functions effortlessly.

2. 📂 Project-Aware Suggestions

Q understands your entire project context. Whether I was building a new React component or updating game state logic, it gave context-relevant suggestions that actually made sense.

3. ⚙️ Quick Iteration with Commands Like `q dev`

The q dev mode let me experiment, iterate, and refine features quickly. The feedback loop was insanely fast — write prompt, review code, test in browser, repeat.

4. 🧪 Testing Integration Made Easy

Even test generation was simplified. Q CLI helped me generate logic tests for validating Sudoku rules with just a couple of lines in my prompt.

5. 📝 Prompt Management = Superpower

You can save, reuse, and version your prompts! Check out the actual prompts I used here:

👉 View Prompts Folder

🕹️ About Sudoku-Q – The Game I Built

Sudoku-Q is a simple browser-based Sudoku game built using:

React + TailwindCSS
Light sound effects for engagement
JSON-based puzzle generation
Deployed via GitHub Pages

I focused on making the game accessible and responsive for players aged 7 and up.

Want to give it a try?

✅ Play it now!

🤖 Prompts That Powered the Game

I designed the game iteratively using prompts like:

"Create a 9x9 Sudoku board component in React"
"Add validation logic to check for correct Sudoku rows and columns"
"Style the board using TailwindCSS with hover effects"
"Add sound on cell entry"

All of them are available for review and inspiration here:

📁 Prompts Folder on GitHub

🔚 Final Thoughts

Using Amazon Q CLI was like pair programming with an expert who never gets tired. Whether you're building games, apps, or utilities — this tool can seriously boost your productivity and creativity.

👉 Try my game: https://amarpreetbhatia.github.io/sudoku-q/

👉 Explore the code: https://github.com/amarpreetbhatia/sudoku-q

👉 Join the contest: #BuildWithAmazonQ

AmazonQCLI

Exploring the Boundless Possibilities of AWS PartyRock: A Journey into Generative AI

amarpreetbhatia — Mon, 11 Mar 2024 10:05:26 +0000

Are you ready to dive into the exhilarating realm of generative AI without the hassle of complex coding?
Look no further than AWS PartyRock – the ultimate playground for AI enthusiasts and budding developers alike.
In this blog post, I'm thrilled to share my firsthand experience with platform that uses AWS Bedrock service and how it's revolutionizing the way we approach AI experimentation.

Check the running demo

AI Email Replies by Empathy Engine - YouTube

"The Empathy Engine" can understand Email Intent & Craft Perfect RepliesWrite Right: AI-Powered Email Response GeneratorNever Say the Wrong Thing Again: Smar...

youtube.com

And try your self at:
The Empathy Engine

Unleashing Creativity with AWS PartyRock

AWS PartyRock provides an intuitive interface that empowers users to unleash their creativity and bring their boldest AI ideas to life and discovering the Magic of Prompt Engineering

At the core of PartyRock's brilliance lies the concept of prompt engineering – a technique that allows users to craft clear and concise instructions to guide AI models towards desired outcomes. With just a few clicks, users can harness the full potential of generative AI, exploring its capabilities and pushing the boundaries of what's possible.

My Journey with AWS PartyRock: A Testimonial

As someone with a passion for AI and a desire to learn, my journey of playing with Foundational Models available in Bedrock has been nothing short of extraordinary. From experimenting with various prompts to witnessing the remarkable transformations brought to life by the AI models, every moment has been an adventure filled with discovery and excitement.

This cutting-edge technology provides users with a solid foundation to build upon, enabling them to create innovative and experimental AI applications with ease. Whether you're a seasoned developer or a curious newcomer, AWS Partyrock's simplifies the learning process and empowers you to unleash your creativity without constraints.

Embark on Your AI Journey Today

Ready to embark on your own AI journey? Visit https://partyrock.aws/ to dive into the world of AWS PartyRock and discover the endless possibilities that await. With its user-friendly interface, powerful Bedrock integration, and thriving community, PartyRock is the perfect platform to unleash your creativity and explore the cutting-edge frontier of generative AI. Let's rock the party and redefine the future of AI together!

Step-by-Step Guide to Migrating from Java 8 to Java 17 (or Later): Tips, Checklist and Best Practices

amarpreetbhatia — Thu, 12 Jan 2023 04:55:16 +0000

This blog post topic would be of interest to software developers, system administrators, and technical managers who work with Java-based applications and need to migrate to a later version of the language.

A detailed migration plan will depend on the specific circumstances of your application and the scale of the migration. However, here's a general outline of the steps that a detailed migration plan might include:

Preparation:

Identify the current Java version and the target version.
Review the changes and new features in the target version of Java.
Assess the impact on the application and identify any potential issues.
Identify any third-party libraries or frameworks used by the application and check for compatibility with the target Java version.

Code changes:

Make any necessary code changes to ensure compatibility with the target Java version.
Remove deprecated or removed features.
Implement new features in the target version.
Refactor or rewrite the code to improve performance and maintainability.

Testing:

Create a test plan for the migration.
Write automated tests for the application.
Test the application thoroughly to ensure that it continues to function correctly after the migration.
Run automated and manual tests to check for compatibility and functionality.
Conduct load testing to ensure that the application can handle the expected workload.

Deployment:

Update build and deployment scripts to use the target Java version.
Update documentation to reflect the new Java version.
Update any configuration files to reflect the new Java version.
Create a backup of the application and its data before deploying the updated version.
Deploy the updated application to a test environment and verify the behavior of the application.

Production deployment:

Perform the migration in a production environment.
Monitor the application for any issues and troubleshoot if necessary.
Roll back to the previous version if there are any major issues in the migration.
Test the application in production environment
Test the application for performance and scalability

Post Migration:

Retire any old version and related resources
Re-evaluate the impact and adjust your plan accordingly
Document all changes and new features
Keep monitoring the system for few days/week

Note: This list is very high level thoughts, and additional steps may be required depending on the specific circumstances of the migration. It is a good practice to have a detailed plan, testing and back-up before migrating in production environment.

Additionally, Would be glad to hear from you can also, how your organization did the migration, what challenges faced and how it was solved.

Thanks for reading!

Using Kubernetes ConfigMaps with Java: Best Practices and Examples

amarpreetbhatia — Wed, 11 Jan 2023 08:44:55 +0000

In Kubernetes, a configMap is a way to store configuration data as key-value pairs. The data stored in a configMap can be used to configure pods and other objects in a Kubernetes cluster.

A configMap can be created and managed using the Kubernetes API, kubectl command-line tool, or declaratively in a yaml file. Once a configMap is created, it can be referenced by pods and other objects in a Kubernetes cluster.

Some common use cases for configMap are:

Storing configuration files, such as application properties files, that need to be shared across multiple pods or containers.
Storing environment variables that need to be passed to a container running in a pod.
Storing initialization scripts or command-line arguments that need to be passed to a container at runtime.
In addition to being referenced by pods, configMap can also be consumed by other resources such as Deployment, StatefulSet using the envFrom field.

It is worth noting that configMap is great for storing non-sensitive data like configuration properties, environment variables, and other metadata. When dealing with sensitive data like passwords and secret keys, it's recommended to use Secret instead.

In this article will try to consume configMap by Java code. This solution assumes the configMap is present and valid in the system and our code will use the Kubernetes Java client library.

To set up the Kubernetes Java client library in your Java project, you can use a build tool such as Maven or Gradle.

Here's an example of how to set it up with Maven:

Add the following dependency to your pom.xml file:

<dependency>
    <groupId>io.kubernetes</groupId>
    <artifactId>client-java</artifactId>
    <version>12.2.2</version>
</dependency>

This will include the Kubernetes Java client library and its dependencies in your project.

Below sample Java program to read a configMap from a Kubernetes cluster:

public class ConfigMapReader {
    public static void main(String[] args) {
        try {
            // Set up the Kubernetes API client
            ApiClient client = Configuration.getDefaultApiClient();
            // Configure the client to use the Kubernetes service account
            client.setAuth("BearerToken", "YOUR_BEARER_TOKEN");
            // Create a CoreV1Api object
            CoreV1Api api = new CoreV1Api(client);
            // Specify the name of the configMap and namespace
            String configMapName = "example-configmap";
            String namespace = "default";
            // Read the configMap from the Kubernetes API
            V1ConfigMap configMap = api.readNamespacedConfigMap(configMapName, namespace, null, null, null);
            // Print the configMap data
            System.out.println(configMap.getData());
        } catch (ApiException e) {
            System.err.println("ApiException: " + e.getResponseBody());
        } catch (Exception e) {
            System.err.println("Exception: " + e.getMessage());
        }
    }
}

This example uses the Kubernetes Java client library to interact with the Kubernetes API. It requires to set up the Kubernetes API client, and configure the client to use a bearer token. It then creates a CoreV1Api object and uses it to read a configMap. The readNamespacedConfigMap method takes several arguments, including the name of the configMap and the namespace it belongs to, and returns a V1ConfigMap object, containing the data of the configMap.

This is a simple example that only demonstrate the basic mechanism to read a configmap. In a real-world application, you will probably want to handle potential exceptions, make sure that the client is configured correctly, and handle cases where the configMap is not found or the API call fails.

Additionally, to read the values from the configMap, you can use configMap.getData().get("KEY_NAME")

It is also good to note that you should follow the best practices for handling authentication and authorization for your use-case.

More details of Kubernetes Client library can be found:

If you have any further questions or thoughts on this topic, please don't hesitate to reach out in the comments section.
Thank you for reading!

Getting Started with the AWS SDK for Java and Lambda

amarpreetbhatia — Mon, 09 Jan 2023 03:37:18 +0000

Are you a Java developer looking to use AWS Lambda in your projects? While JavaScript is the most common language used for writing Lambda functions, it is also possible to use Java to create and invoke these serverless functions. In this article, I will provide a step-by-step guide for setting up Java and Maven to use the AWS SDK for Lambda. By the end of this tutorial, you will have a solid understanding of how to use Java to work with AWS Lambda and incorporate serverless computing into your Java-based projects.

To set up Java and Maven to use the AWS SDK for Lambda, you will need to:

Install the Java Development Kit (JDK) if you do not already have it installed. You can download the JDK from the Oracle website: JAVA SDK Try to use LTS version i.e. JDK 17 in latest, but ideally any JAVA SDK after 1.8+ is ok to run this sample.
Install Maven if you do not already have it installed. You can find instructions for installing Maven on the Apache Maven website: Maven
Once you have installed JDK and Maven, create a new Maven project in your preferred development environment. Add the AWS SDK for Java as a dependency in your Maven project by including the following code in your pom.xml file:

<dependencies>
    <dependency>
        <groupId>com.amazonaws</groupId>
        <artifactId>aws-java-sdk</artifactId>
        <version>1.11.871</version>
    </dependency>
</dependencies>

Here is an example of a simple Java program that you can run on AWS Lambda

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;

public class HelloWorld implements RequestHandler<Object, String> {
    public String handleRequest(Object input, Context context) {
        return "Hello, World!";
    }
}

This program implements the RequestHandler interface, which is the main interface that you need to implement to create a function that can be invoked by AWS Lambda. The handleRequest method is the function handler, which takes an input object and a context object as arguments and returns a string.

To run this program on AWS Lambda, you would need to package it into a .zip file along with any dependencies and upload it to AWS Lambda using the steps described in my previous message. The fully qualified name of the class containing the function handler method would be HelloWorld.

To set up a Java program for AWS Lambda, follow these steps:

Create a new AWS Lambda function in the AWS Management Console.
Choose "Java" as the runtime for your function.
Under "Function code," choose "Upload a .zip file" as the code entry type and upload your .zip file containing your Java code and any dependencies.
In the "Handler" field, specify the fully qualified name of the class that contains the function handler method. The function handler is the method that will be invoked when your Lambda function is called.
Configure the function's execution role and any other desired settings, such as the function's memory and timeout settings.
Save your function and test it using the "Test" button in the AWS Management Console. That's it! Your Java program should now be set up and ready to run on AWS Lambda. You can invoke your function using the AWS Management Console, the AWS CLI, or by making an API call.

Now, Here is a sample Java program that demonstrates to invoke an AWS Lambda function:
But, first we need to get an access Token, To set the access token in your Java code when invoking an AWS Lambda function, you will need to do the following:

Obtain an access token from AWS Identity and Access Management (IAM). You can use the GetAccessToken API to request an access token for a specific IAM user or role.
Set the access token in your Java code by including it in the InvokeRequest object that you use to invoke your Lambda function. You can set the access token by calling the withAccessToken method of the InvokeRequest object and passing in the access token as a string.

import com.amazonaws.services.lambda.AWSLambda;
import com.amazonaws.services.lambda.AWSLambdaClientBuilder;
import com.amazonaws.services.lambda.model.InvokeRequest;
import com.amazonaws.services.lambda.model.InvokeResult;

public class LambdaInvoker {
    public static void main(String[] args) {
        // Create a client for interacting with AWS Lambda
        AWSLambda lambdaClient = AWSLambdaClientBuilder.defaultClient();

        // Set the name of the Lambda function to invoke
        String functionName = "myFunction";

        // Set the input for the Lambda function
        String input = "{\"key\":\"value\"}";

        // Set the access token for the InvokeRequest
        String accessToken = "ACCESS_TOKEN_HERE";

        // Create an InvokeRequest object
        InvokeRequest invokeRequest = new InvokeRequest()
                .withFunctionName(functionName)
                .withPayload(input)
                .withAccessToken(accessToken);

        // Invoke the Lambda function and get the response
        InvokeResult invokeResult = lambdaClient.invoke(invokeRequest);

        // Print the response
        System.out.println(new String(invokeResult.getPayload().array()));
    }
}

This program will invoke the AWS Lambda function named myFunction, passing it the JSON input {"key":"value"}. It will then print the response returned by the function.

In the End one can say, why not to use AWS API Gateway for Integrating to call the Lambda function, which is very valid and depends on the use case of the project you are working on.

There are broadly three invocation models and the example above comes under "Synchronous invocation", other two are Asynchronous invocation and Polling invocation. More details can be read from Lambda invocation

I hope this helps! If you have any thoughts or questions about using Java with AWS Services, please don't hesitate to reach out in the comments below. I would love to hear from like minded people and gain more knowledge.

AWS Lambda Cost Optimization: Tips and Tricks for Reducing Your Serverless Costs

amarpreetbhatia — Sun, 08 Jan 2023 11:55:08 +0000

There are several ways to optimise costs with AWS Lambda:

Use the AWS Lambda pricing calculator to estimate the cost of your function. This can help you understand the cost implications of your configuration choices.
AWS estimation calculator is a great tool for calculator.aws for cost projections

Choose the right balance of memory and CPU capacity for your functions. AWS Lambda charges you for the number of requests and the duration of each request. By increasing the amount of memory you allocate to your function, you can increase its CPU capacity and possibly reduce the duration of each request. This can result in lower costs.

To increase the memory allocated to your AWS Lambda function, follow these steps:

Sign in to the AWS Management Console and navigate to the AWS Lambda page.
Find the function you want to modify, and click on its name to go to the function’s configuration page.
On the configuration page, click the “Configuration” tab.
Scroll down to the “Memory (MB)” field and use the slider or enter a value to increase the amount of memory allocated to your function.
Click the “Save” button at the top of the page to save your changes

Use AWS Lambda reserved capacity. You can purchase a reservation for a specific number of capacity units for a 1 or 3 year term, which can significantly reduce your Lambda costs.

To reserve capacity for your AWS Lambda functions, follow these steps:

Sign in to the AWS Management Console and navigate to the AWS Lambda page.
Click the “Reserved capacity” tab.
Click the “Purchase reserved capacity” button.
Select the number of capacity units you want to purchase and the term (1 or 3 years) for your reservation.
Select the functions you want to apply the reserved capacity to, or create a new function.
Review your reservation details and click “Continue to review.”
Review the reservation details and click “Create reservation.”

Use versioning and aliases to ensure that you have control over which version of your function is being used. This allows you to test new versions of your function before routing all traffic to it, which can help you avoid unexpected increases in cost.
Use AWS CloudWatch to monitor the performance of your functions and identify any cost drivers. This can help you identify opportunities to optimise your functions and reduce your costs.

To view AWS CloudWatch logs for your AWS Lambda functions, follow these steps:

Sign in to the AWS Management Console and navigate to the AWS CloudWatch page.
In the left-hand navigation menu, click “Logs.”
In the “Log Groups” section, click the log group for your Lambda function. The log group will have the same name as your function.
Select the time range you want to view logs for, and click the “Go” button.
You will see a list of all log streams for your function, grouped by function version or alias. Click on a log stream to view its logs.
You can use the search box and filter options to find specific log events within the log stream.
You can also use CloudWatch to set up alarms and notifications based on specific log events, or to visualise your logs data using CloudWatch dashboards.

Consider using other, more cost-effective services in combination with AWS Lambda. For example, you might use Amazon S3 for long-term storage or Amazon EC2 for workloads that are better suited to a traditional server architecture.
If you have a large number of functions that are not used frequently, consider using the AWS Lambda function auto-scaling feature to scale your functions in and out based on actual usage. This can help you save money by only paying for the capacity you need.

I hope these tips help!

Kubernetes for Java Developers: A Step-by-Step Guide to Containerizing Your Applications

amarpreetbhatia — Fri, 06 Jan 2023 10:36:28 +0000

Kubernetes is an open-source container orchestration system that can be used to automate the deployment, scaling, and management of containerized applications. There are several benefits that a Java developer might realise by using Kubernetes:

Improved resource utilisation: As mentioned previously, Kubernetes can improve resource utilisation by allowing you to more efficiently pack containers onto hosts. This can lead to cost savings and improved performance.
Greater flexibility: Kubernetes allows you to easily deploy and manage Java applications across a cluster of hosts, which can be more flexible than managing a fleet of virtual machines. Better scalability: Kubernetes makes it easy to scale Java applications up or down by adding or removing containers from the cluster. This can be more efficient and faster than scaling virtual machines.
Enhanced reliability: Kubernetes can automatically detect and replace failed containers, and it can also perform rolling updates to ensure that applications remain available during updates.
Simplified management: Kubernetes provides a unified interface for managing containerized applications, which can simplify the process of deploying and managing Java applications at scale.
Streamlined development process: Kubernetes can make it easier for Java developers to build and test applications by providing a consistent environment for development, staging, and production.

Overall, Kubernetes can help Java developers build and manage highly scalable and reliable applications more efficiently.

Let’s put below Hello World Sample to Kubernetes,

public class ClassA {

public static void main(String[] args) {

System.out.println(“Hello World”);

}

}

To containerize a Java program for Kubernetes, you will need to follow these steps:

Create a Dockerfile for your Java program. A Dockerfile is a text file that contains instructions for building a Docker image. Your Dockerfile should include instructions for installing any dependencies your Java program requires, as well as instructions for copying your Java code into the image and setting the command to run your program. Here is an example of a simple Dockerfile for a Java program:

FROM openjdk:8-jre-alpine
ADD my-java-program.jar /app/my-java-program.jar
CMD [“java”, “-jar”, “/app/my-java-program.jar”]

Build the Docker image using the Dockerfile. You can do this using the docker build command. For example:

docker build -t my-java-program .

Test the Docker image by running a container using the docker run command. For example:

docker run -it my-java-program

Push the Docker image to a Docker registry. A Docker registry is a repository for storing and distributing Docker images. You can use a public registry such as Docker Hub, or you can set up your own private registry.
Create a Kubernetes deployment to manage the containers running your Java program. A deployment is a higher-level object that manages a group of replicas of your application. You can create a deployment using a YAML file that specifies the details of your deployment, including the number of replicas you want to run and the Docker image to use. Here is an example YAML file for a deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-java-program
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-java-program
  template:
    metadata:
      labels:
        app: my-java-program
    spec:
      containers:
      - name: my-java-program
        image: my-java-program
        ports:
        - containerPort: 8080

Apply the deployment to your Kubernetes cluster using the kubectl command. For example:
That’s it! Your Java program should now be running in a container on your Kubernetes cluster. You can use the kubectl command to view the status of your deployment and make any necessary adjustments.

Forem: amarpreetbhatia

Building a Windows Productivity Tool Using GitHub Copilot CLI

What I Built

Demo

My Experience with GitHub Copilot CLI

From Vibe Coding to Spec-Driven Development that Slashed Dev Time

🚀 From 'Vibe' to Victory: How Spec-Driven Development in Kiro IDE Slashed My Dev Time by 44%

🤯 The Two Worlds of Coding

What is "Vibe Coding"?

Enter: Spec-Driven Development (SDD)

🎯 The Project: Agile Planning Tool

💡 1. Why Spec-Driven Development Won: Complex Features Became Simple

A. Authentication (GitHub OAuth)

B. Real-Time Collaboration

C. Drag-and-Drop Story Management

📊 2. The Numbers: A Quantitative Victory

Development Time Comparison

Code Quality Metrics

✍️ 3. Testing Became Natural

🛠️ Tools That Made It Possible

🛑 Common Objections Answered

✅ Final Thoughts

From Idea to Production: Building a Secure Image Crawler with Kiro's AI-Powered Development

.kiro/hooks/test-generator.md

.kiro/hooks/security-audit.md

.kiro/hooks/doc-sync.md

Built a Sudoku Game Using Amazon Q CLI on WSL Ubuntu – Try It Out!

🧠 Why Amazon Q CLI Blew My Mind (5 Cool Features)

1. 🔄 Natural Language to Code Conversion

2. 📂 Project-Aware Suggestions

3. ⚙️ Quick Iteration with Commands Like q dev

4. 🧪 Testing Integration Made Easy

5. 📝 Prompt Management = Superpower

🕹️ About Sudoku-Q – The Game I Built

🤖 Prompts That Powered the Game

🔚 Final Thoughts

AmazonQCLI

Exploring the Boundless Possibilities of AWS PartyRock: A Journey into Generative AI

AI Email Replies by Empathy Engine - YouTube

Step-by-Step Guide to Migrating from Java 8 to Java 17 (or Later): Tips, Checklist and Best Practices

Using Kubernetes ConfigMaps with Java: Best Practices and Examples

Getting Started with the AWS SDK for Java and Lambda

AWS Lambda Cost Optimization: Tips and Tricks for Reducing Your Serverless Costs

Kubernetes for Java Developers: A Step-by-Step Guide to Containerizing Your Applications

3. ⚙️ Quick Iteration with Commands Like `q dev`