DEV Community: unni mana

The One Tool That Changed How I Think About API Performance

unni mana — Mon, 22 Jun 2026 04:07:28 +0000

API stress testing is broken. Here's how we're fixing it.

Let's be honest for a moment. If you've ever had to run a stress test, you know the drill. You fire up a tool like ab or wrk, squint at a wall of numbers in your terminal, and then... well, then what? You copy-paste the numbers into a document, try to make sense of them, and pray your manager or team can decipher the same cryptic metrics you just spent an hour interpreting.

I've been there, and I felt there had to be a better way. That frustration is exactly why I built GoStress.

It's not just another load-testing tool. It's a simple, open-source CLI utility written in Go that solves a core problem: making performance data not just accessible, but genuinely understandable and actionable.

The Problem with Traditional Stress Tests

When you're testing an API, the most common question isn't just "Can it handle 1,000 requests?" It's, "What does that mean for our users?"

Raw numbers—throughput, latency, error codes—only tell a fraction of the story. They don't visually show you where your system starts to buckle. They don't easily highlight the relationship between latency and success rates.

Many existing tools treat the output of a test as a final, static artifact. You get a summary, maybe a CSV file, and the onus is on you to make it meaningful.

GoStress flips this script. It embraces the idea that a test's report is just as important as the test itself.

The 'Aha!' Moment: One Command to a Full HTML Report

What if, instead of a wall of text, you got a polished, shareable HTML report with interactive charts for reliability, latency, and status codes after every single test run?

That's the core promise of GoStress.

One single command is all it takes:

go run . --url http://your-api.com

That's it. That command will send 10 concurrent requests for 10 seconds to your target and generate a report.json file. But the real magic happens when you add the --formats html flag.

go run . --url http://your-api.com --formats html

Now, you get report.html. Open it in your browser, and you're not looking at raw data. You're looking at a narrative summary with built-in charts for:

Throughput & RPS

Latency Percentiles

HTTP Status Code Distribution

Transport Errors

It turns a complex performance test into a story that anyone can understand. This isn't just a developer tool; it's a bridge for communication with QA, product managers, and stakeholders who need to see the impact of a change.

Power and Simplicity Under the Hood

GoStress is designed to be incredibly easy to use, but it's not simplistic. It's packed with features you'd expect from a robust testing tool, all accessible through clear, well-documented flags.

For instance, you can quickly ramp up a more complex test scenario:

go run . \ --url http://localhost:8080/api/orders \ --c 50 \ --d 30 \ --method POST \ --payload '{"customerId":123}' \ --headers 'Authorization: Bearer token, X-Trace: demo' \ --success-status '200-299,409' \ --rps 200 \ --formats 'json,csv,html' \ --output reports/run-01

This command demonstrates the tool's flexibility:

Precise Control: Fine-tune concurrency (-c), duration (-d), and global RPS limits (--rps).

Real-World Scenarios: Support for POST requests with JSON payloads and custom headers.

Flexible Assertions: Define what constitutes a "successful" request with the --success-status flag. Your API might return a 409 Conflict for a valid business logic case, and now you can count it as a success.

Rich Output: Generate reports in json, csv, and html formats for maximum flexibility.

An Unexpected Game-Changer: The Built-in Dashboard

One of the standout features of GoStress is the built-in web dashboard. You can launch it with a single flag:

go run . --serve-web --web-addr :8088 --dashboard-report report.json

This starts a lightweight, protected web server featuring:

A sign-up and login page

A protected dashboard

APIs to import and view report data

This transforms GoStress from a one-off testing tool into a performance observability platform. You can now:

Share Reports Visually: Let your team access a clean, visual representation of performance data without sending files around.

Compare Runs: By loading different JSON reports, you can view and compare results in a consistent UI.

Centralize Viewing: Use the dashboard to host reports from tests run in CI/CD pipelines.

The Developer Experience (DX) Makes All the Difference

As developers, we know that our tools shape our workflows. A tool that is cumbersome to use often gets used less. GoStress is designed for an exceptional developer experience.

Zero Configuration: It works out-of-the-box with sensible defaults.

Clear and Immediate Output: Whether you're running a quick sanity check or a complex scenario, the feedback is immediate and clear.

Re-Run and Re-Report: You can use the --from-report flag to re-render an existing report.json as a polished HTML or CSV file. This is perfect if you want to visualize historical test results without running a new test.

Single Binary: Being written in Go, it compiles into a single, statically linked binary that's incredibly easy to install and run on any platform (Linux, macOS, Windows).

Real-World Use Cases

CI/CD Pipeline Integration

Imagine integrating GoStress into your CI/CD pipeline. Every time you deploy, you automatically run a stress test and generate an HTML report. This report can be stored as an artifact and viewed by the team, ensuring performance regressions are caught early.
# In your CI pipeline go run github.com/unnivm/gostress \ --url $STAGING_URL \ --c 100 \ --d 60 \ --rps 500 \ --formats html \ --output reports/deploy-${GITHUB_SHA}

Performance Regression Detection

Use --from-report to re-render historical reports and compare them side-by-side in the dashboard. This makes it easy to spot performance trends over time.
Load Testing Microservices

With support for POST requests, headers, and payloads, GoStress is perfect for testing individual microservices with realistic traffic patterns.

What Sets GoStress Apart

Feature GoStress Traditional Tools
HTML Reports with Charts ✅ Built-in ❌ Manual work needed
Web Dashboard ✅ Included ❌ Requires separate setup
Custom Success Status Codes ✅ Flexible ❌ Usually fixed
Global RPS Limiting ✅ Shared across workers ❌ Often per-worker only
Re-run Reports from JSON ✅ Supported ❌ Not common
Simple CLI Flags ✅ Intuitive ❌ Often complex

Getting Started in 2 Minutes

Clone the repository:

git clone https://github.com/unnivm/gostress.git cd gostress

Run your first test:
go run . --url https://your-api.com --formats html

Open report.html in your browser and explore the insights.

That's it! No complex setup, no configuration files, no learning curve.

The Open Source Ethos

GoStress is completely free and open-source. It's a tool built for the community, by a developer who was tired of the status quo. The goal is to make effective performance testing accessible to everyone, from indie hackers deploying their first API to enterprise teams managing complex microservices.

What you can do to help:

⭐ Star the repository on GitHub

🐛 Report issues or suggest features

🔧 Contribute code or documentation

📢 Share it with your network

Go Ahead, Give It a Try

The next time you need to stress test your application, give GoStress a shot. It's more than just a tool; it's a new way of thinking about performance testing. It's about spending less time deciphering data and more time understanding your system.

Take the tool for a spin, generate that beautiful HTML report, and see for yourself what a difference it makes.

Repository: https://github.com/unnivm/gostress

Drop your thoughts in the comments below! 👇

GoStress is proudly built with Go. It's simple, it's powerful, and it's free. ❤️

AI based Puzzle Book

unni mana — Tue, 09 Jun 2026 02:26:02 +0000

Rapid acquisition of knowledge often requires a hands-on approach, as true learning frequently occurs through direct application. To enhance one's understanding of Artificial Intelligence, it is essential to first master the fundamental terminology associated with the field. This foundational knowledge serves to re-orient the reader's perspective as they explore more complex concepts within the discipline.

Reflecting this pedagogical philosophy, I have developed a word search puzzle book dedicated to the subject of Artificial Intelligence. While the format mirrors traditional puzzle publications, the content is specifically curated to focus on AI-related themes. This interactive medium allows learners to familiarize themselves with complex nomenclature in a low-stress environment, reinforcing memory through visual recognition.

The book contains fifty specialized puzzles designed to stimulate cognitive engagement and strengthen the conceptual grasp of readers seeking to contribute meaningfully to this domain. Each puzzle is meticulously crafted to cover a diverse range of sub-topics, ensuring a broad exposure to the evolving landscape of AI technology and theory.

The volume is systematically organized to include comprehensive solutions for every puzzle, supplemented by a glossary that provides detailed explanations of key Artificial Intelligence terms. By combining the challenge of word discovery with a structured reference guide, the book serves as both a recreational activity and a robust educational tool for aspiring practitioners.

AI Word Search Puzzle

I Wrote a Book on Quarkus (And Here is a Free Chapter to Prove It)

unni mana — Fri, 22 May 2026 04:33:18 +0000

For years, Spring Boot was my go-to for Java microservices. It worked, so I didn't question it. But as we started moving more services to Kubernetes and AWS Lambda, the problems became impossible to ignore.

Cold starts taking 5-10 seconds.
Containers eating up 800MB+ of memory.
Wasting money just to keep services alive.

Then I found Quarkus. It starts in ~0.01 seconds as a native image and runs on a fraction of the memory. It was a game-changer.

So I wrote a book about it.

*📚 The Book: Practical Quarkus: From Zero to Native
*
It is a hands-on guide for Java developers who want to build cloud-native microservices that actually work. Every command and code block in the book has been tested on a real machine. No fluff. No copy-paste errors.

You can find it here on Amazon: Practical Quarkus: From Zero to Native

But I am not here to just ask you to buy a book. I am here to give you something useful first.

🎁 Your Free Chapter: "Why Quarkus?"

Since the first 10% of the book is free on Amazon as the "Look Inside" sample, I want to share exactly what you will learn in Chapter 1. It answers the most important question: "Should I even care about Quarkus?"

Here is a taste.

🚀 Build Your First Quarkus Endpoint (In Under 10 Minutes)

This is the exact code from Chapter 1. You can run it on your laptop right now.

Create a new Quarkus project using Maven:

mvn io.quarkus.platform:quarkus-maven-plugin:3.14.0:create \ -DprojectGroupId=org.example \ -DprojectArtifactId=code-with-quarkus \ -Dextensions=resteasy-reactive cd code-with-quarkus ./mvnw quarkus:dev

*2. Add a REST endpoint:
*
Create the file src/main/java/org/example/GreetingResource.java:

`package org.example;

import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;

@path("/hello")
public class GreetingResource {

@GET
@Produces(MediaType.TEXT_PLAIN)
public String hello() {
    return "Hello from Quarkus. Spring Boot took 3 seconds. I took 0.3.";
}

3. See it works:
Open your browser to http://localhost:8080/hello

You will see the message: Hello from Quarkus. Spring Boot took 3 seconds. I took 0.3.

That is it. You just ran your first Quarkus app. The dev mode even supports hot reload—change the message and save the file, and it updates instantly. No restart.

Use Quarkus if... Stick with Spring Boot if...
Startup time under 1 second matters: Startup time doesn't matter (long-running servers)
Running on Lambda, Fargate, or Knative: Running on traditional EC2 or dedicated servers
Memory is expensive (< 200MB per pod): You have plenty of RAM (2GB+ per pod)
You want native compilation with GraalVM: You rely on heavy reflection or dynamic proxies
Building 20+ microservices: Building one monolithic application

*📖 What's Next in the Book?
*
If you found this useful, the book goes much further. The first four chapters (available now) cover:

Chapter 2: Full CRUD with PostgreSQL and Panache (20 lines of code)

Chapter 3: Validation and proper HTTP error handling (404, 400)

Chapter 4: Logging and configuration for dev/prod environments

The book is 31% complete. When you buy it now, you pay once and get all future chapters (including the one on native executables) for free.

🔗 Get the Book & Code

Amazon (Live Now):[Practical Quarkus: From Zero to Native](https://www.amazon.com/dp/B0H2JR9DLD)

GitHub (All code examples): (github.com/unnivm/practical-quarkus)

*❓ Questions?
*
Ask me anything in the comments below. I will answer every one.

If you pick up the book, please leave a review on Amazon. It helps other Java developers find it.

Happy coding.

The Future of Autonomous Innovation: Inside the Gemini Enterprise Agent Platform|Google Cloud Next '26

unni mana — Sat, 25 Apr 2026 16:29:08 +0000

The landscape of artificial intelligence is shifting from static models to dynamic, autonomous entities. At Google Cloud Next '26, the unveiling of the Gemini Enterprise Agent Platform marked a pivotal moment in this evolution. Designed as a comprehensive ecosystem, the platform empowers organizations to build, scale, and manage production-ready AI agents capable of operating with a degree of independence previously confined to science fiction. To demonstrate this power, Google showcased a complex marathon simulation in Las Vegas, where hundreds of agents collaborated to manage everything from logistics to security in real-time.

Building the Foundation with ADK

At the heart of the developer experience is the Agent Development Kit (ADK). This toolkit simplifies the creation of modular agents by providing ready-to-use skills. A critical component of the ADK is its integration with the Model Context Protocol (MCP), which enables agents to seamlessly connect with Google Cloud services. This modularity ensures that developers don’t have to reinvent the wheel for every new capability; instead, they can assemble sophisticated agents that are deeply integrated with their existing cloud infrastructure from day one.

Universal Collaboration: A2A and the Agent Registry

One of the most significant hurdles in multi-agent systems is communication. The Gemini platform solves this through the Agent-to-Agent (A2A) protocol. This universal standard allows agents to advertise their specific capabilities and communicate with one another without the need for brittle, manual API integrations. Supporting this is the Agent Registry, a central directory functioning much like a DNS for AI. It allows agents to discover peers across a network, resolve identities, and find the specific skill sets required to complete a complex task collaboratively. Furthermore, the A2UI feature allows these agents to generate their own dynamic interfaces, ensuring they can interact not just with each other, but with human users in a friendly and intuitive manner.

Securing the Frontier: Red and Green Agents

Security in an autonomous world is paramount. The platform introduces a sophisticated "Red vs. Blue" dynamic powered by AI. The Red Agent acts as a "Friendly Pentester," an AI-powered security specialist that probes environments to identify exploitable risks. It doesn’t just scan for vulnerabilities; it validates them by analyzing attack paths—the actual route an intruder might take from the public internet to sensitive data. This provides a realistic view of runtime risks that traditional code analysis often misses.

The Fixer: Green Agent Integration

When a vulnerability is found, the Wiz-integrated Green Agent steps in. While the Red Agent finds the holes, the Green Agent is the "fixer." It suggests root-cause remediations, such as downgrading IAM privileges or patching authentication bypasses. It provides full transparency, showing developers the exact steps taken to discover the flaw. Most impressively, it can initiate developer workflows to apply these fixes directly to the code, closing the loop between threat detection and resolution.

Enterprise Management and Scalability

Beyond development and security, the platform excels in operational management. With Memory Bank and session management, agents remain stateful, recalling previous interactions and learnings. Specialized knowledge is provided via Retrieval-Augmented Generation (RAG) and AlloyDB vector functions, allowing agents to understand context like local city regulations. For operations teams, Cloud Assist provides observability, allowing for natural language debugging and proactive fixes. The infrastructure itself is built to scale, moving effortlessly from Cloud Run for simpler tasks to Google Kubernetes Engine (GKE) for massive, multi-agent simulations.

Accessibility and Open Innovation

Google is committed to making this technology accessible. The platform supports no-code integration, allowing teams to create agents using natural language prompts via Gemini Enterprise. To further foster innovation, Google has open-sourced the entire code for the Las Vegas marathon simulation. This repository and accompanying lab materials provide a roadmap for developers worldwide to start building the next generation of autonomous agents on a platform designed for safety, scale, and collaboration.

LLM Observability tool

unni mana — Sat, 25 Apr 2026 06:21:53 +0000

I just created an open source LLM observability named "TraceLM" that can track the following activities:

token cost
token length
latency information etc

The following tool can be found here:

https://github.com/unnivm/tracelm-java-agent

This tools offers a very cool dashboard to track the above information. The user is required to login to access this dashboard.

This tool currently supports only Java based applications as it is basically working based on instrumentation technique. But, this tool will be extended ti support other programming languages as well.

This project is under development and am going to add more features to to so that the idea is to make it an enterprise ready product.

A Leisurely Developer

unni mana — Mon, 30 Mar 2026 15:24:42 +0000

This is a submission for the 2026 WeCoded Challenge: Echoes of Experience