Forem: ashwithpoojary98

Gemma 4 Challenge: Build with Gemma 4

ashwithpoojary98 — Sun, 24 May 2026 12:08:34 +0000

This is a submission for the Gemma 4 Challenge: Build with Gemma 4

What I Built

IncidentLens — a self-hosted incident response copilot for SRE and platform teams.

When a P1 alert fires at 2 AM, the on-call engineer's first 30 minutes are mostly tab-switching: Grafana → Kibana → Jaeger → GitHub → Slack → runbook wiki. The actual reasoning is maybe 20% of that wall-clock time. The other 80% is swivel-chair work — copy-pasting timestamps, remembering which query syntax goes where, asking on Slack who deployed last.

IncidentLens collapses that loop. Point it at your observability backends (Loki/Elastic, Prometheus, Jaeger/Tempo, GitHub, Slack) via a YAML config. When an incident opens, a Gemma 4–powered agent fans out across all of them in parallel, builds a unified timeline, and returns:

A ranked root-cause hypothesis with the full evidence trail behind it
A remediation command ready to execute, with estimated recovery time
A postmortem draft that writes itself as a byproduct of the diagnosis

Crucially, the whole thing runs inside your VPC. No production logs leave the perimeter. That's the unlock for regulated industries — finance, healthcare, government — where existing AIOps SaaS isn't an option because data residency rules forbid shipping prod telemetry to a third-party cloud.

The engineer's job collapses from investigate to verify and approve. Every tool call the agent made, every signal it weighted, every alternative hypothesis it discarded is auditable — because nobody is going to trust an AI rollback they can't inspect.

Demo

🎥 Video walkthrough —

🔗 Live demo —

Code

📦 Repository — (github.com/ashwithpoojary98/incident-lens)

Stack:

Spring Boot 3 orchestration service (alert ingestion, tool routing, audit logging)
Python agent sidecar serving Gemma 4 via vLLM with native function calling
Kafka between them for streaming tool results into the timeline as they arrive
PostgreSQL for incident state, Redis for active-incident working memory

How I Used Gemma 4

Gemma 4 is the agent. The Spring Boot service is plumbing — every actual diagnostic decision flows through a Gemma 4 function-calling loop.

Current setup (local dev): Gemma 4 E4B

I'm building and iterating on a single laptop, so I started with E4B. Two reasons it was the right pick for the dev phase:

It validates the architecture without GPU infra. If the tool-use loop, prompt scaffolding, and timeline reconstruction work on E4B, they'll work better on larger models. Iterating on a 4B model means seconds per cycle, not minutes.
128K context is already enough to prototype long-context behavior. I can fit 1–2 hours of logs plus a distributed trace plus recent commits and exercise the full end-to-end plumbing without simulating it.

Production target: Gemma 4 26B A4B (MoE)

The plan is to swap to 26B MoE before any real deployment. The reasons are specific, not generic:

MoE economics. 3.8B active params means I can serve it on a single L40S or RTX 6000 and still fan out 5–10 parallel tool calls without the model becoming the bottleneck. Dense 31B would cost meaningfully more per incident.
256K context. Full incident timelines (logs + traces + commits + Slack thread) fit without RAG fragmentation that loses temporal ordering — and temporal ordering is the signal in incident response.
Configurable thinking modes. Fast/shallow on the first signal so the engineer sees a hypothesis in seconds; deep reasoning when they follow up with "but why did the retry storm start?"
Native function calling. Non-negotiable. The agent lives or dies on tool-use accuracy across log/metric/trace backends. Pre-Gemma-4 this had to be bolted on with prompt scaffolding; Gemma 4 ships it.
Apache 2.0 + self-hostable. The whole product premise is "your prod logs never leave your network." Hosted APIs literally cannot solve this market.

I deliberately did not pick 31B Dense. Overkill for tool-using reasoning, harder to serve cheaply, and the marginal quality gain doesn't justify the inference cost when the bottleneck is tool-call accuracy, not raw reasoning ceiling.

Why this E4B → 26B MoE path works

Gemma 4 keeps a consistent function-calling API across the family, so the upgrade is essentially a config line swap. I get to validate the entire product loop locally on commodity hardware, then move to the production-grade model without rewriting the agent. That portability — same prompt format, same tool schemas, same thinking-mode controls from 4B all the way up — is honestly the most underrated thing about the Gemma 4 release, and it shaped my whole development approach.

Why Being Both SDET and Developer Makes You a Stronger Platform Engineer

ashwithpoojary98 — Fri, 03 Apr 2026 15:58:36 +0000

After nearly five years in IT, I’ve worked across roles—as an SDET, a developer, and now a platform engineer. Along the way, I didn’t just write tests or build features. I experienced the full lifecycle of software, including all the friction that comes after development.

And that changed everything.

The Problem I Kept Running Into

As an SDET and developer, my job didn’t end after writing code. Every issue meant going through the same painful cycle:

Build the application
Deploy it to an environment
Run tests and validate
Debug and repeat

This process could easily take an entire day.

The hardest part? I didn’t fully control it.

If something broke at night, I had to wait for SREs, DevOps, or DBAs. Permissions, access, and dependencies slowed everything down. Fixing a small issue often required multiple teams to be available.

That’s when I realized:

The real bottleneck wasn’t code, it was the system around the code.

What SDET Taught Me

Being an SDET gave me a strong foundation in:

Thinking about edge cases and failure scenarios
Building robust automation frameworks
Ensuring quality at every stage
Designing systems that are testable by default

I didn’t just test software, I learned how software breaks.

What Development Taught Me

As a developer, I learned:

How to design and build scalable systems
Writing clean, maintainable code
Understanding architecture and performance
Shipping features with real user impact

I didn’t just find problems, I built solutions.

Where It All Came Together: Platform Engineering

Platform engineering became the natural next step.

Instead of repeatedly fixing issues inside the same broken process, I started focusing on improving the process itself.

Today, I build platforms that:

Automate the entire build, test, and deployment lifecycle
Enable self-service deployments for developers
Reduce dependency on multiple teams
Provide consistent environments across development, staging, and production

In short, I don’t just build software anymore. I build systems that help others build software faster.

The Advantage of SDET + Developer Experience

Having both backgrounds is a huge advantage in platform engineering:

1. You Build with Quality in Mind

You don’t treat testing as an afterthought. You design platforms where quality checks are built-in.

2. You Understand the Full Lifecycle

From writing code → testing → deploying → monitoring—you’ve lived every step.

3. You Reduce Friction for Teams

You know where developers and testers struggle, so you design platforms that remove those pain points.

4. You Automate What Actually Matters

Not just scripts, but meaningful automation that saves hours or days of effort.

5. You Think in Systems, Not Just Code

You move from solving isolated problems to improving the entire engineering workflow.

Why Platform Engineering is the Future

Modern software development is no longer just about writing code- it’s about delivering it quickly, reliably, and at scale.

Platform engineering enables that by:

Turning infrastructure into self-service
Using Infrastructure as Code for consistency and speed
Eliminating manual handoffs and delays
Empowering developers to own their code in production

As systems grow more complex, the teams that win will be the ones who can ship faster without sacrificing quality.

And that requires strong platforms.

Final Thoughts

Looking back, being both an SDET and a developer wasn’t just part of my journey; It was my biggest advantage.

It taught me how to think about quality, build scalable systems, and most importantly, identify the real bottlenecks in software delivery.

Because in the end:

Great engineers don’t just write code—they build systems that make everything else faster.

And that’s what "platform engineering" is all about.

Automating Flutter App Using Flutter Appium driver

ashwithpoojary98 — Sat, 08 Jul 2023 10:07:59 +0000

Why Flutter is the most popular cross-platform mobile SDK??

Running a development team for each mobile platform sucks up resources from other work. Flutter is the most popular way for one development team to build on all platforms.

What is Flutter?
Flutter is Google’s free, open-source software development kit (SDK) for cross-platform mobile application development. Using a single platform-agnostic codebase, Flutter helps developers build high-performance, scalable applications with attractive and functional user interfaces for Android or IOS. Flutter relies on a library of pre-made widgets that make it simple for even people with limited programming or development experience to launch their own mobile applications quickly.

A list of companies doing noteworthy work with Flutter

As of January 2023, there are over 700,000 apps in the Play Store that are built with Flutter, and one in five new apps on the Play Store use Flutter, more than all other cross-platform frameworks put together. Flutter is picking up market share from other cross-platform frameworks, which are flat or declining over the last twelve months.
Top Popular App built with flutter

Alibaba Groups
Google pay
ByteDance
BMW
Dream11
Nubank
Pubg Mobile
AWS Amplify
Google ClassRoom
Zerodha

How to Automate Flutter App
Flutter app automation is not always straightforward.
Flutter apps render using a two-stage process:

Widget tree
Render Object tree

The flutter rendering engine is highly efficient and can render complex UIs at high frame rates. This is because the rendering engine uses a number of optimizations, such as caching render objects and batching draws calls.

There are a few different ways to automate flutter apps.
1. Flutter Driver:

Flutter driver used to interact with the app's UI, verify that the app is behaving as expected and perform other tasks.
To use flutter driver, you need to install it's dependency in your flutter project

dev_dependencies:
  flutter_test:
    sdk: flutter
  flutter_driver:
    sdk: flutter
  test: any

Sample test

import 'package:flutter_driver/driver_extension.dart';
import 'package:test/main.dart' as app;

void main() {
  enableFlutterDriverExtension();
  app.main();
}

test('increments the counter', () async {
      await driver.tap(incrementButtonFinder);

      expect(await driver.getText(counterTextFinder), "1");
    });

Challenges that can encounter when using Flutter Driver to Automate Flutter apps:

Writing test in other languages than Dart
Running integration test for Flutter app with embedded webview or native view, or existing native app with embedded Flutter view
Running test on multiple devices simultaneously(Parallel Run)
Running integration test on device farms, such as Sauce Labs, HeadSpin, AWS, Firebase

2. Appium Flutter Driver

Appium Flutter Driver is the most popular tool used to automate Flutter apps.
Appium is a cross-platform automation tool that can be used to automate apps that run on a variety of platform, including flutter.

Pre Requisite
Your Flutter app-under-test (AUT) must be compiled in debug or profile mode, because Flutter Driver does not support running in release mode. Also, ensure that your Flutter AUT has enableFlutterDriverExtension() before running App. Then, please make sure your app imported flutter_driver package as its devDependencies as well.

dev_dependencies:
  flutter_test:
    sdk: flutter
  flutter_driver:
    sdk: flutter
  test: any

import 'package:flutter/material.dart';
import 'package:flutter_driver/driver_extension.dart';
import 'package:functional_widget_annotation/functional_widget_annotation.dart';
import 'package:hello_world/stream.dart';

part 'main.g.dart';

void main() {
enableFlutterDriverExtension(enableTextEntryEmulation: false);
 init();
  runApp(MyApp());
}

@widget
Widget myApp() => MaterialApp(
  title: 'Counter App',
  home: MyHomePage(title: 'Counter App Home Page'),
);



@widget
Widget myHomePage(BuildContext context, {String title}) => Scaffold(
  appBar: AppBar(
    title: Text(title),
  ),
  body: Center(
    child: Column(
      mainAxisAlignment: MainAxisAlignment.center,
      children: <Widget>[
        Text(
          'You have pushed the button this many times:',
        ),
        Tooltip(
          message: 'counter_tooltip',
          child: StreamBuilder<int>(
            stream: counterStream,
            builder: (context, snapshot) {
              return Text(
                '${snapshot.data}',
                key: Key('counter'),
                style: Theme.of(context).textTheme.display1,
                semanticsLabel: 'counter_semantic',
              );
            }
          ),
        ),
        FlatButton(
          onPressed: () {
            Navigator.push(
              context,
              MaterialPageRoute(
                  builder: (context) => Scaffold(
                        appBar: AppBar(
                          title: Text("Second Route"),
                        ),
                        body: Center(
                          child: SecondPage(),
                        ),
                      )),
            );
          },
          child: Text(
            'Go to next route',
            key: Key('next_route_key'),
          ),
        ),
      ],
    ),
  ),
  floatingActionButton: FloatingActionButton(
    // Provide a Key to this button. This allows finding this
    // specific button inside the test suite, and tapping it.
    key: Key('increment'),
    onPressed: () => plusClickSink.add(null),
    tooltip: 'Increment',
    child: Icon(Icons.add),
  ),
);

@widget
Widget secondPage() => ListView(
  padding: const EdgeInsets.all(8.0),
  children: <Widget>[
    Container(
      height: 100,
      color: Colors.amber[600],
      child: const Center(child: Text('This is 2nd route')),
    ),
    Container(
      height: 200,
      color: Colors.amber[500],
      child: const Center(child: Text('Entry B')),
    ),
    Container(
      height: 500,
      color: Colors.amber[100],
      child: const Center(child: Text('Entry C')),
    ),
    Container(
      height: 1000,
      color: Colors.amber[100],
      child: const Center(child: Text('Entry D')),
    ),
    Container(
      height: 1000,
      color: Colors.amber[100],
      child: const Center(
          child: TextField(
        decoration: InputDecoration(
          border: OutlineInputBorder(),
          labelText: 'Sample Input',
        ),
      )),
    ),
  ],
);

Automation Code:

Add maven dependency to pom.xml
<dependency>
    <groupId>io.github.ashwithpoojary98</groupId>
    <artifactId>appium_flutterfinder_java</artifactId>
    <version>1.0.1</version>
</dependency>


import io.appium.java_client.AppiumDriver;

public class FlutterFinderExampleTest {
    RemoteWebDriver driver;

    @BeforeMethod
    public void openApp() throws MalformedURLException {
        DesiredCapabilities capabilities = new DesiredCapabilities();
        capabilities.setCapability("deviceName", "emulator-5554");
        capabilities.setCapability("platformName", "Android");
        capabilities.setCapability("noReset", true);
        capabilities.setCapability("app", "");
        capabilities.setCapability("automationName", "Flutter");
        driver = new AppiumDriver(new URL("http://0.0.0.0:4723/wd/hub"), capabilities);
        driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(30));
    }

    @Test
    public void appiumFlutterTest() {
        FlutterFinder finder = new FlutterFinder(driver);
        WebElement element = finder.byValueKey("increment");
        element.click();
    }

    @AfterMethod
    public void tearDown() {
        if (driver != null) {
            driver.quit();
        }
    }
}

ashwithpoojary98 / javaflutterfinder

Flutter driver with Java implementation

Appium Flutter Finder Java

Flutter appium driver is automation tool with java implementation.

maven-plugin

Setup

Add maven dependency to pom.xml

<dependency>
    <groupId>io.github.ashwithpoojary98</groupId>
    <artifactId>appium_flutterfinder_java</artifactId>
    <version>1.0.9</version>
</dependency>

Maven Center Repo link

https://mvnrepository.com/artifact/io.github.ashwithpoojary98/appium_flutterfinder_java

Usage

import io.appium.java_client.AppiumDriver
public class FlutterFinderExampleTest {
    RemoteWebDriver driver;

    @BeforeMethod
    public void openApp() throws MalformedURLException {
        DesiredCapabilities capabilities = new DesiredCapabilities();
        capabilities.setCapability("deviceName", "emulator-5554");
        capabilities.setCapability("platformName", "Android");
        capabilities.setCapability("noReset", true);
        capabilities.setCapability("app", "");
        capabilities.setCapability("automationName", "Flutter");
        driver = new AppiumDriver(new URL("http://0.0.0.0:4723/wd/hub"), capabilities);
        driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(30));
    }

    @Test
    public void appiumFlutterTest

…

View on GitHub

If you have any queries at all, please feel free to reach out.
Gmail: ashwithpoojary98@gmail.com
Insta: ashwith__poojary
Github: https://github.com/ashwithpoojary98

Thank you....