Forem: Shreya Nalawade

Running Gemma 4 Inside a Docker Container with GPU Passthrough

Shreya Nalawade — Mon, 18 May 2026 19:24:34 +0000

This is a submission for the Gemma 4 Challenge: Write About Gemma 4

Here's a situation every ML team eventually hits.

Your intern gets Gemma 4 running locally. Beautiful. Fast. Impresses the standup. Then they leave for the semester. Three weeks later, nobody can reproduce the setup. The model was in a path that no longer exists. The Python version was wrong. The CUDA libraries conflicted with PyTorch. Someone pip installed something globally and broke everything.

This is why Docker exists. And yet, every Gemma 4 setup guide I've found uses either the Ollama GUI, LM Studio's drag-and-drop interface, or bare ollama run commands that vanish when the terminal closes. None of them answer the actual question a dev team has:

How do we version-control this, ship it to staging, and have it work the same way every time?

This guide answers that. By the end, you'll have:

A Dockerfile your team can pin, review, and modify in a PR
A docker-compose.yml that brings up the full stack with one command
A running Gemma 4 endpoint that speaks OpenAI's API format — meaning zero changes to any code that already calls GPT-4o

Let's build it.

Why Docker + GPU Is Annoying (and How It Actually Works)

Before the files, a quick mental model — because this is where most people get confused.

CUDA is not inside your container. The NVIDIA driver lives on the host machine. The container runtime (Docker) needs a way to reach through the container wall and talk to those drivers. That bridge is the NVIDIA Container Toolkit.

Here's the flow:

Your Container
    └── CUDA libraries (inside the image)
          └── NVIDIA Container Runtime  ← the bridge
                └── Host NVIDIA Driver  ← never inside the container
                      └── Physical GPU

This means:

You do NOT need to install CUDA on your host. Only the NVIDIA driver.
You do NOT bundle the driver inside your Docker image. Only CUDA libraries.
The container toolkit version on your host must be compatible with your driver version.

A common gotcha: if your host driver is old (e.g., 470.x), it cannot run CUDA 12.x containers. The CUDA version inside your image must be less than or equal to what your driver supports. Check first:

nvidia-smi
# Look for: "CUDA Version: XX.X" in the top-right corner
# That's the maximum CUDA your driver supports

Prerequisites Checklist

Before touching any Docker file, verify these four things on your host machine:

# 1. Confirm NVIDIA GPU is visible
lspci | grep -i nvidia

# 2. Check driver is installed and working
nvidia-smi

# 3. Check Docker version (need 19.03+ for native --gpus support)
docker --version

# 4. Check NVIDIA Container Toolkit is installed
nvidia-ctk --version

If step 4 fails, install the toolkit:

# Ubuntu/Debian
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | \
  sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg

curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
  sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit

# Wire it into Docker
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

# Test — you should see nvidia-smi output from inside a container
docker run --rm --gpus all nvidia/cuda:12.3.0-base-ubuntu22.04 nvidia-smi

If that last command shows your GPU, you're ready. If it errors, stop here and fix the driver — no amount of clever Dockerfiles will help.

The Setup We're Building

We're going to run three containers in a single Compose stack:

Container	What it does	Port
`gemma4`	Ollama serving Gemma 4 (with GPU)	`11434` (internal)
`litellm`	OpenAI-compatible proxy in front of Ollama	`8000` (external)
`model-puller`	One-shot container that pulls the model on first boot	—

The LiteLLM proxy is the key piece most guides skip. It translates OpenAI API calls (/v1/chat/completions) into Ollama's native format, adds API key auth, rate limiting, and request logging — all without touching your application code.

Project Structure

Create this directory layout before writing any files:

gemma4-stack/
├── .env                    # Secrets and config — never commit this
├── .env.example            # Template for new team members
├── docker-compose.yml      # The full stack
├── Dockerfile.ollama       # Custom Ollama image with health checks
├── litellm/
│   └── config.yaml         # LiteLLM model routing config
├── scripts/
│   └── pull-model.sh       # Idempotent model pull script
└── tests/
    └── smoke_test.py       # Verify the stack works end-to-end

Step 1: The `.env` File

# .env — copy from .env.example and fill in your values
# !! Never commit this file — add .env to .gitignore

# Which Gemma 4 variant to run
# Options: gemma4:e2b | gemma4:e4b | gemma4:26b | gemma4:31b
GEMMA_MODEL=gemma4:26b

# API key for LiteLLM (clients use this to authenticate)
# Generate a random one: openssl rand -hex 32
LITELLM_MASTER_KEY=sk-your-secret-key-here

# How long Ollama keeps the model in VRAM after the last request
# Increase this if you have spare VRAM and want faster cold starts
OLLAMA_KEEP_ALIVE=10m

# Max parallel inference requests (tune to your VRAM)
OLLAMA_NUM_PARALLEL=2

# HuggingFace token — needed only if you pull gated models
HF_TOKEN=

# .env.example — commit this
GEMMA_MODEL=gemma4:26b
LITELLM_MASTER_KEY=sk-CHANGE-ME
OLLAMA_KEEP_ALIVE=10m
OLLAMA_NUM_PARALLEL=2
HF_TOKEN=

Step 2: The Dockerfile

This is where we diverge from every "just use the ollama image" guide. Our custom image adds:

A proper health check endpoint (so Compose knows when Ollama is actually ready)
A non-root user (security baseline for any production-adjacent setup)
Pinned Ollama version (reproducibility)

# Dockerfile.ollama
# Pin to a specific Ollama release — update deliberately, not accidentally
FROM ollama/ollama:0.9.3

# Metadata
LABEL maintainer="your-team@yourcompany.com"
LABEL description="Ollama serving Gemma 4 with GPU passthrough"
LABEL gemma.version="gemma4"

# GPU access configuration
# NVIDIA_VISIBLE_DEVICES and NVIDIA_DRIVER_CAPABILITIES tell the
# container runtime which GPU capabilities to expose.
# "compute" = CUDA, "utility" = nvidia-smi
ENV NVIDIA_VISIBLE_DEVICES=all
ENV NVIDIA_DRIVER_CAPABILITIES=compute,utility

# Ollama configuration
ENV OLLAMA_HOST=0.0.0.0
ENV OLLAMA_ORIGINS=*

# Keep the model warm in VRAM (overridable via docker-compose env)
ENV OLLAMA_KEEP_ALIVE=10m

# Number of parallel inference slots
# Each slot uses roughly model_size / 2 additional VRAM
ENV OLLAMA_NUM_PARALLEL=2

# Flash attention — reduces memory for long contexts
ENV OLLAMA_FLASH_ATTENTION=1

# Model storage location inside the container
# We'll mount a volume here to persist across container restarts
ENV OLLAMA_MODELS=/models

# Create the models directory and set ownership
RUN mkdir -p /models && chmod 755 /models

# Expose Ollama's API port
EXPOSE 11434

# Health check: ask Ollama if it's ready
# --start-period gives it 60s to load before health checks count
HEALTHCHECK --interval=15s --timeout=10s --retries=5 --start-period=60s \
  CMD curl -sf http://localhost:11434/api/tags || exit 1

# Default command — starts Ollama server
CMD ["ollama", "serve"]

Why pin ollama:0.9.3 and not ollama:latest?

Because latest on a production service means "surprise breaking changes on every docker pull." Pin it. Update it intentionally via PR. When a new Ollama release drops and the team wants to update, the diff is one line and the change is reviewable.

Step 3: The Model Pull Script

This script runs once on startup and is idempotent — running it twice does nothing harmful:

#!/usr/bin/env bash
# scripts/pull-model.sh
# Pulls the Gemma 4 model if not already present
# Safe to run multiple times — checks before pulling

set -euo pipefail

OLLAMA_HOST="${OLLAMA_HOST:-http://gemma4:11434}"
MODEL="${GEMMA_MODEL:-gemma4:26b}"

echo "==> Waiting for Ollama to be ready at ${OLLAMA_HOST}..."

# Wait up to 5 minutes for Ollama to respond
for i in $(seq 1 60); do
  if curl -sf "${OLLAMA_HOST}/api/tags" > /dev/null 2>&1; then
    echo "==> Ollama is up."
    break
  fi
  echo "    Attempt ${i}/60 — retrying in 5s..."
  sleep 5
done

# Check if model already exists
if curl -sf "${OLLAMA_HOST}/api/tags" | grep -q "\"${MODEL}\""; then
  echo "==> Model '${MODEL}' already present. Skipping pull."
  exit 0
fi

echo "==> Pulling model: ${MODEL}"
echo "    This can take 5–20 minutes depending on your connection."
echo "    The 26B model is ~15GB. Get a coffee."

curl -sf -X POST "${OLLAMA_HOST}/api/pull" \
  -H "Content-Type: application/json" \
  -d "{\"name\": \"${MODEL}\", \"stream\": false}"

echo "==> Pull complete. Model '${MODEL}' is ready."

chmod +x scripts/pull-model.sh

Step 4: LiteLLM Config

LiteLLM is the OpenAI-compatible gateway. This config tells it that "gemma-4" (what your app calls) maps to "ollama_chat/gemma4:26b" (what Ollama actually serves):

# litellm/config.yaml
model_list:
  # Gemma 4 26B MoE — best balance of speed and quality
  - model_name: gemma-4
    litellm_params:
      model: ollama_chat/gemma4:26b
      api_base: http://gemma4:11434

  # Gemma 4 E4B — fast, low VRAM, good for quick tasks
  - model_name: gemma-4-fast
    litellm_params:
      model: ollama_chat/gemma4:e4b
      api_base: http://gemma4:11434

  # Gemma 4 31B Dense — maximum quality, needs 24GB+ VRAM
  - model_name: gemma-4-max
    litellm_params:
      model: ollama_chat/gemma4:31b
      api_base: http://gemma4:11434

litellm_settings:
  # Log all requests (set to false in prod if you handle this elsewhere)
  set_verbose: false

  # Drop unsupported params instead of erroring
  # Gemma doesn't support every OpenAI parameter (e.g., logprobs)
  drop_params: true

  # Request timeout in seconds
  request_timeout: 120

general_settings:
  # Master key for authentication
  # Clients send: Authorization: Bearer sk-your-secret-key-here
  master_key: "os.environ/LITELLM_MASTER_KEY"

Step 5: The docker-compose.yml

This is the centrepiece. Read it carefully — every decision has a comment explaining why:

# docker-compose.yml
# Gemma 4 production-grade local inference stack
# Usage: docker compose up -d
# First run: docker compose up -d && docker compose logs -f model-puller

name: gemma4-stack

services:

  # ─────────────────────────────────────────────
  # OLLAMA: The inference engine with GPU access
  # ─────────────────────────────────────────────
  gemma4:
    build:
      context: .
      dockerfile: Dockerfile.ollama
    container_name: gemma4-ollama

    # GPU passthrough — this is the magic line
    # "count: all" exposes every GPU on the host
    # Change to "count: 1" or "device_ids: ['0']" to pin a specific GPU
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

    # Model storage: named volume persists across container recreations
    # Without this, you re-download 15GB every time you update the image
    volumes:
      - gemma4-models:/models

    environment:
      OLLAMA_KEEP_ALIVE: ${OLLAMA_KEEP_ALIVE:-10m}
      OLLAMA_NUM_PARALLEL: ${OLLAMA_NUM_PARALLEL:-2}
      OLLAMA_FLASH_ATTENTION: "1"
      OLLAMA_MODELS: /models

    # Do NOT expose port 11434 to the host
    # All external traffic goes through LiteLLM on port 8000
    # This prevents clients from bypassing auth
    expose:
      - "11434"

    restart: unless-stopped

    healthcheck:
      test: ["CMD", "curl", "-sf", "http://localhost:11434/api/tags"]
      interval: 15s
      timeout: 10s
      retries: 5
      start_period: 60s

  # ─────────────────────────────────────────────
  # MODEL PULLER: Downloads Gemma 4 on first boot
  # Exits cleanly after pulling — not a long-running service
  # ─────────────────────────────────────────────
  model-puller:
    image: curlimages/curl:latest
    container_name: gemma4-model-puller

    volumes:
      - ./scripts/pull-model.sh:/pull-model.sh:ro

    environment:
      OLLAMA_HOST: http://gemma4:11434
      GEMMA_MODEL: ${GEMMA_MODEL:-gemma4:26b}

    entrypoint: ["/bin/sh", "/pull-model.sh"]

    depends_on:
      gemma4:
        condition: service_healthy

    # This container should exit 0 after pulling the model
    restart: "no"

  # ─────────────────────────────────────────────
  # LITELLM: OpenAI-compatible API gateway
  # Your apps connect to THIS, not to Ollama directly
  # ─────────────────────────────────────────────
  litellm:
    image: ghcr.io/berriai/litellm:main-stable
    container_name: gemma4-litellm

    volumes:
      - ./litellm/config.yaml:/app/config.yaml:ro

    environment:
      LITELLM_MASTER_KEY: ${LITELLM_MASTER_KEY}

    command: ["--config", "/app/config.yaml", "--port", "8000"]

    ports:
      # THIS is the only port exposed to your host machine
      # http://localhost:8000/v1 — drop-in replacement for OpenAI
      - "8000:8000"

    depends_on:
      gemma4:
        condition: service_healthy

    restart: unless-stopped

    healthcheck:
      test: ["CMD", "curl", "-sf", "http://localhost:8000/health"]
      interval: 20s
      timeout: 10s
      retries: 3

# ─────────────────────────────────────────────
# VOLUMES
# ─────────────────────────────────────────────
volumes:
  gemma4-models:
    driver: local
    # Uncomment to bind to a specific host path instead:
    # driver_opts:
    #   type: none
    #   o: bind
    #   device: /data/gemma4-models

networks:
  default:
    name: gemma4-net

Step 6: Boot It Up

# Clone or create the project directory
cd gemma4-stack

# Copy the env template and fill in your master key
cp .env.example .env
# Edit .env — at minimum, set LITELLM_MASTER_KEY

# Build the Ollama image and start the stack
docker compose up -d

# Watch the model download (first run only — this takes a while)
docker compose logs -f model-puller

# Once model-puller exits, check everything is healthy
docker compose ps

Expected output from docker compose ps once everything is running:

NAME                   IMAGE                          STATUS
gemma4-ollama          gemma4-stack-gemma4            Up (healthy)
gemma4-litellm         ghcr.io/berriai/litellm:...   Up (healthy)
gemma4-model-puller    curlimages/curl:latest         Exited (0)

The model-puller showing Exited (0) is correct — it finished its job and stopped cleanly.

Step 7: Test the OpenAI-Compatible Endpoint

Your stack is now running a drop-in OpenAI replacement at http://localhost:8000/v1. Test it:

# Check available models
curl http://localhost:8000/v1/models \
  -H "Authorization: Bearer ${LITELLM_MASTER_KEY}"

# Send a chat completion — same format as OpenAI
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ${LITELLM_MASTER_KEY}" \
  -d '{
    "model": "gemma-4",
    "messages": [
      {
        "role": "system",
        "content": "You are a senior backend engineer doing code review."
      },
      {
        "role": "user",
        "content": "Review this Python function and identify any issues:\n\ndef get_user(id):\n    return db.query(f\"SELECT * FROM users WHERE id={id}\")"
      }
    ],
    "temperature": 0.3,
    "max_tokens": 512
  }'

Expected response — Gemma 4 should immediately flag the SQL injection:

{
  "id": "chatcmpl-...",
  "object": "chat.completion",
  "model": "gemma-4",
  "choices": [{
    "message": {
      "role": "assistant",
      "content": "Critical issue: SQL injection vulnerability on line 2. The `id` parameter is interpolated directly into the query string with an f-string. An attacker could pass `id = '1 OR 1=1 --'` and retrieve all users. Fix: use parameterized queries:\n\n```

python\ndef get_user(user_id: int):\n    return db.query(\n        \"SELECT * FROM users WHERE id = %s\",\n        (user_id,)\n    )\n

```\n\nAlso: rename the parameter from `id` to `user_id` — `id` shadows a Python built-in."
    },
    "finish_reason": "stop"
  }]
}

Step 8: Drop It Into Your Existing Code

Here's the part that makes this setup valuable to a team. If you already have code calling OpenAI, you change two lines:

Python (openai SDK)

# Before — calling OpenAI
from openai import OpenAI

client = OpenAI(api_key="sk-your-openai-key")

# After — calling your local Gemma 4 stack
from openai import OpenAI
import os

client = OpenAI(
    base_url="http://localhost:8000/v1",  # ← changed
    api_key=os.environ["LITELLM_MASTER_KEY"],  # ← changed
)

# Everything below is identical — no other changes needed
response = client.chat.completions.create(
    model="gemma-4",  # or "gemma-4-fast" for E4B, "gemma-4-max" for 31B
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Explain what a Docker volume is in one sentence."},
    ],
    temperature=0.7,
    max_tokens=200,
)

print(response.choices[0].message.content)

Node.js / TypeScript

import OpenAI from "openai";

// Same two-line swap
const client = new OpenAI({
  baseURL: "http://localhost:8000/v1",
  apiKey: process.env.LITELLM_MASTER_KEY,
});

const response = await client.chat.completions.create({
  model: "gemma-4",
  messages: [
    { role: "user", content: "Write a TypeScript type for a paginated API response." }
  ],
});

console.log(response.choices[0].message.content);

LangChain

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    base_url="http://localhost:8000/v1",
    api_key="your-litellm-master-key",
    model="gemma-4",
    temperature=0,
)

response = llm.invoke("What are the SOLID principles? Give me one sentence per principle.")
print(response.content)

Step 9: The Smoke Test

Add this to your CI pipeline or run it after deployment to verify the stack is working:

# tests/smoke_test.py
"""
Smoke test for the Gemma 4 Docker stack.
Run with: python tests/smoke_test.py
Exit 0 = healthy. Exit 1 = something's broken.
"""

import os
import sys
import time
from openai import OpenAI

BASE_URL = os.environ.get("GEMMA_BASE_URL", "http://localhost:8000/v1")
API_KEY = os.environ.get("LITELLM_MASTER_KEY", "sk-test")
MODEL = os.environ.get("GEMMA_MODEL_ALIAS", "gemma-4")

def check(name: str, condition: bool, detail: str = ""):
    if condition:
        print(f"  ✓ {name}")
    else:
        print(f"  ✗ {name}{': ' + detail if detail else ''}")
        sys.exit(1)

print(f"\nSmoke test — {BASE_URL}\n")

client = OpenAI(base_url=BASE_URL, api_key=API_KEY)

# Test 1: Models endpoint
models = client.models.list()
model_ids = [m.id for m in models.data]
check("Models endpoint", len(model_ids) > 0, f"got: {model_ids}")
check(f"Model '{MODEL}' available", MODEL in model_ids)

# Test 2: Basic chat completion
start = time.time()
resp = client.chat.completions.create(
    model=MODEL,
    messages=[{"role": "user", "content": "Reply with exactly the word PONG and nothing else."}],
    max_tokens=10,
    temperature=0,
)
elapsed = time.time() - start

reply = resp.choices[0].message.content.strip().upper()
check("Chat completion returns", "PONG" in reply, f"got: {reply!r}")
check("Response time < 30s", elapsed < 30, f"took {elapsed:.1f}s")

# Test 3: Streaming
chunks = []
for chunk in client.chat.completions.create(
    model=MODEL,
    messages=[{"role": "user", "content": "Count to 3, one number per line."}],
    max_tokens=30,
    stream=True,
):
    if chunk.choices[0].delta.content:
        chunks.append(chunk.choices[0].delta.content)

check("Streaming works", len(chunks) > 0, f"got {len(chunks)} chunks")

print(f"\nAll checks passed. Stack is healthy.\n")

Useful Day-to-Day Commands

# Start the stack
docker compose up -d

# Tail logs from all containers
docker compose logs -f

# Tail logs from one container
docker compose logs -f gemma4

# Check GPU utilization inside the container
docker exec gemma4-ollama nvidia-smi

# List loaded models and their VRAM usage
docker exec gemma4-ollama ollama ps

# Pull a different model (e.g., try 31B if you have the VRAM)
docker exec gemma4-ollama ollama pull gemma4:31b

# Hard restart (keeps model volume intact)
docker compose restart gemma4

# Full teardown — preserves the model volume
docker compose down

# NUCLEAR: full teardown including the 15GB model volume
# Only do this if you want to re-download everything
docker compose down -v

# Update to a newer Ollama version (edit Dockerfile.ollama first)
docker compose build --no-cache gemma4
docker compose up -d gemma4

# Check container resource usage
docker stats gemma4-ollama

Hardware Decision Guide

Not sure which Gemma 4 variant to put in your .env? Here's the honest breakdown:

Your hardware	Set `GEMMA_MODEL` to	Why
RTX 3090/4090 (24 GB VRAM)	`gemma4:31b`	Full quality, fits comfortably
RTX 3080/4080 (12–16 GB VRAM)	`gemma4:26b`	MoE activates only 3.8B — fits and runs fast
RTX 3060/4060 (8 GB VRAM)	`gemma4:e4b`	Edge model, good quality, 3.5 GB VRAM
Any GPU with 6 GB VRAM	`gemma4:e2b`	Lightweight, still genuinely useful
CPU only (no GPU)	`gemma4:e2b`	Slow but functional; ~3–5 tok/s on modern CPU
2× GPUs (any combo)	`gemma4:31b` + tensor parallel	See multi-GPU note below

For multi-GPU setups, add to your Ollama environment:

environment:
  OLLAMA_GPU_LAYERS: 999      # Offload all layers to GPU
  OLLAMA_SCHED_SPREAD: "1"    # Spread across multiple GPUs

Common Errors and Fixes

nvidia-smi: command not found inside container
Your NVIDIA Container Toolkit isn't wired into Docker. Re-run sudo nvidia-ctk runtime configure --runtime=docker and restart Docker.

CUDA error: no kernel image is available for execution on the device
Your GPU is too old for the CUDA version in the Ollama image. Check nvidia-smi for your driver version and use an older Ollama base image with a compatible CUDA tag.

LiteLLM returns APIConnectionError
The litellm container can't reach gemma4. Check they're on the same network: docker network inspect gemma4-net. The service name gemma4 in the LiteLLM config must match the Compose service name exactly.

docker compose up says GPU not found on Linux
The Docker daemon didn't get restarted after toolkit installation. Run sudo systemctl restart docker.

Model-puller keeps restarting instead of exiting
Ollama isn't healthy yet. Increase start_period in the Ollama healthcheck from 60s to 120s — large models take longer to initialize on slow disks.

What This Unlocks for Your Team

Once this stack is running, here's what your team gets for free:

Reproducibility. git clone + cp .env.example .env + docker compose up -d = working Gemma 4 in under 20 minutes for any new team member. No "it works on my machine."

Version control. Every change to the model, Ollama version, or config goes through a PR. Your ML setup is as auditable as your application code.

OpenAI drop-in. Any code that calls OpenAI works immediately. Switch between gemma-4 (local) and gpt-4o (cloud) by changing one environment variable. Useful for cost comparisons and offline development.

Privacy by default. No token leaves the machine. Customer data, proprietary code, internal documents — all processed locally with no third-party API calls.

Zero cloud dependency. The stack works on a laptop, a workstation, an on-prem server, or an air-gapped environment. The only network requirement is the initial model download.

References

NVIDIA Container Toolkit documentation — Installation and Docker configuration guide. https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html
Ollama Docker Hub — Official Ollama images and tags. https://hub.docker.com/r/ollama/ollama
LiteLLM documentation — OpenAI proxy setup and config reference. https://docs.litellm.ai
Gemma 4 on Ollama — Model tags and size reference. https://ollama.com/library/gemma4
NVIDIA Specialized Docker Configurations — NVIDIA_VISIBLE_DEVICES and capability flags. https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/docker-specialized.html
vLLM production deployment with Gemma 4 — For teams needing multi-user concurrency beyond what Ollama provides. https://gemma4-ai.com/blog/gemma4-vllm-deploy

How Gemma 4's Per-Layer Embeddings Actually Work — And Why E2B Punches Above 2B

Shreya Nalawade — Mon, 18 May 2026 18:34:51 +0000

How Gemma 4's Per-Layer Embeddings Actually Work — And Why E2B Punches Above 2B

This is a submission for the Gemma 4 Challenge: Write About Gemma 4

Every benchmark article about Gemma 4 E2B says roughly the same thing: "Despite being a 2B model, it outperforms older 7B models on reasoning tasks." Then they move on. Nobody explains why. Nobody opens the hood.

The answer is a mechanism called Per-Layer Embeddings (PLE) — and once you understand it, you'll never read an LLM parameter count the same way again.

This article breaks down the exact mechanism, walks through it with a concrete analogy, compares E2B's real benchmark numbers against similarly-sized rivals, and explains what PLE means for quantization and deployment.

The Problem PLE Was Built to Solve

To understand PLE, you first need to understand the problem it solves in standard transformers.

In a vanilla transformer (GPT-2, Llama 3, early Gemma generations), every token gets one embedding vector at the input layer. That vector is a fixed lookup from a table: token ID 4821 → a 4096-dimensional float vector. The model then passes this vector through 32 (or 64, or 80) layers of attention and feed-forward networks. The original embedding never refreshes — it just flows forward as a residual signal.

Here's the constraint this creates. Imagine you're writing a mystery novel and you introduce the word "bank" on page 1. The model has to encode — in that single input embedding — everything that word might mean across the entire 128,000-token context:

Is it a riverbank?
A financial institution?
Is it a verb ("bank the aircraft")?
Is the protagonist going to rob it on page 80?

The embedding vector has to carry all this ambiguity, and each layer has to do the hard work of resolving it through attention alone. For large models with billions of parameters spread across 80 layers, attention has enough capacity to do this. For a small 2B model with only 18–26 layers, the pressure on that single input embedding is enormous. The model either oversimplifies meaning early, or spends most of its capacity just resolving token ambiguity instead of reasoning.

This is the "bottleneck" that stunts small models. And it's exactly what PLE dismantles.

What Per-Layer Embeddings Actually Do

The idea, when you see it plainly, is almost obvious.

Instead of one embedding at the input, give every layer its own embedding signal for every token.

Here's what that looks like architecturally. Alongside the standard embedding table, the E2B model has a second embedding table — embed_tokens_per_layer — that produces a packed vector for every token. That packed vector is then sliced into 35 pieces (one per decoder layer). Each slice is a small, low-dimensional vector (~305 dimensions) that gets injected into its corresponding layer as an additional residual signal.

In pseudocode pulled directly from the Hugging Face Transformers implementation:

# Standard embedding (unchanged)
hidden_states = embed_tokens(input_ids)  # shape: [batch, seq, 2304]

# PLE: one big lookup, then slice per layer
ple_packed = embed_tokens_per_layer(input_ids)
# shape: [batch, seq, num_layers * per_layer_dim]
# → reshaped to [batch, seq, 35, 305]

# At each decoder layer i:
layer_signal = ple_packed[:, :, i, :]   # [batch, seq, 305]
# Combined with context-aware projection, scaled by 1/√2
# Injected into the residual stream AFTER attention + FFN
hidden_states = hidden_states + gate(layer_signal)

The key mechanics here, each worth unpacking:

1. The signal is gated, not blindly added.
The injection uses a learned gate — the current hidden state decides how much of the per-layer token signal to absorb. If layer 18 has already resolved the ambiguity of "bank" from context, the gate suppresses the token-identity refresh. If it's still confused, the gate opens. This is adaptive, not mechanical.

2. It combines two components.
Each per-layer vector is a sum of:

A token-identity component — what this token is, looked up from the PLE table
A context-aware component — a learned projection of the main embedding, capturing what the token means given what came before

These two signals are summed and scaled by 1/√2 (normalizing their combined magnitude) before injection. The model learns to balance raw token identity with contextual interpretation at every depth.

3. The compute cost is almost nothing.
The PLE table is just an array lookup — table[token_id]. No matrix multiplication. No attention. The entire 35-layer lookup for a token takes microseconds and runs once at the start of inference, not once per layer. This is why PLE is so efficient: it adds representational richness with almost zero inference overhead.

A Personal Example: The Word "Fine"

Let me make this concrete with a short passage:

"The weather is fine today. The fine for speeding is ₹2,000. I feel fine about it, honestly."

In a standard small transformer, the token "fine" receives the same initial embedding vector all three times. That vector has to somehow encode noun-fine (penalty), adjective-fine (weather quality), and verb-phrase-fine (emotional state) simultaneously. The model's shallow layer count means it may never fully disambiguate all three — leading to reasoning errors downstream.

With PLE, here's what happens differently:

At layer 5 (early syntactic processing), the PLE signal for "fine" reinforces its token identity — "this is an ambiguous adjective/noun." The gate is open because the context hasn't resolved it yet.
At layer 14 (mid-depth semantic processing), the model has seen "speeding" and "₹2,000" in the context window. The context-aware component of the PLE signal now weights toward the noun/penalty sense. The hidden state updates accordingly.
At layer 26 (deep reasoning), the phrase "I feel fine about it" provides strong cues. The PLE signal now reinforces the emotional state reading. The gate opens again for this instance while suppressing it for the others.

Each occurrence of "fine" gets its own resolved representation at depth — not because attention alone did the work, but because the per-layer signal kept refreshing the token's identity throughout the network. The model doesn't have to "remember" ambiguity resolution from layer 5 all the way to layer 26.

For a 2B model, this is the difference between reasoning correctly and reasoning confidently but wrongly.

The Numbers: What This Actually Unlocks

Here's where PLE stops being theoretical and starts being remarkable. These are verified benchmark figures for Gemma 4 E2B (2.3B effective parameters):

Benchmark	Gemma 4 E2B	Phi-3 Mini (3.8B)	Llama 3.2 3B	What it tests
AIME 2026 (math)	competitive edge model	not published	not tested	Hard math olympiad
MMLU Pro	outperforms class	~53%	~45%	Graduate-level knowledge
Context window	128K tokens	128K	128K	Long-context recall
Active parameters	2.3B	3.8B	3B	Inference cost
Total parameters	5.1B	3.8B	3B	Storage weight
RAM (Q4 quantized)	~1.5 GB	~2.4 GB	~2.0 GB	Device requirement
Multimodal inputs	Text, image, audio	Text only	Text only	Input modalities

The headline number that matters: E2B carries 5.1B total parameters but runs at 2.3B inference cost. The gap between those two numbers — 2.8B parameters — is almost entirely the PLE embedding tables.

Storage is cheap. Compute is expensive. PLE exploits this asymmetry precisely.

For a larger-scale reference: the Gemma 4 31B (no PLE, standard architecture) scores 85.2% on MMLU Pro and 89.2% on AIME 2026. Even the tiny E4B (4.5B effective) hits 42.5% on AIME — more than double what Gemma 3 27B managed (20.8%) on the same benchmark. PLE does not fully explain this jump (architecture improvements, training data quality, and reasoning mode all contribute), but it is the mechanism that makes the efficiency ratio possible.

How E2B Compares to Other Small Models

It helps to see E2B in context against the current small-model landscape:

vs. Phi-4 Mini / Phi-3 Mini (Microsoft)

Phi models achieve strong reasoning through data curation — training on extremely high-quality synthetic reasoning chains. They don't use PLE. The result is impressive per-parameter quality, but Phi-4 (3.8B) requires more RAM than E2B, lacks native multimodal support, and has no audio input. For edge deployment on a phone or IoT device, E2B wins on memory footprint and modality breadth.

vs. Qwen 3.5 0.8B / 1.8B (Alibaba)

Qwen's small models use standard embeddings with a larger vocabulary (151,936 tokens). They're competitive on multilingual text tasks. However, they lack audio input and their context window at the smallest tier is shorter. PLE's per-layer disambiguation gives E2B an edge on long-context reasoning tasks where token ambiguity compounds over distance.

vs. Llama 3.2 3B (Meta)

Llama 3.2 3B is a fine model for its size but uses standard transformer architecture with no equivalent of PLE. It requires more RAM than E2B for similar quality, lacks multimodal input, and was trained primarily on text. For developers targeting mobile or edge, Llama has no models at this tier at all — Llama 4's smallest model (Scout) requires approximately 70 GB of VRAM.

vs. Gemma 3 2B (previous generation)

This is the cleanest comparison because it isolates the architectural change. Gemma 3 2B and Gemma 4 E2B are both Google DeepMind models, similar training compute, similar target hardware. The introduction of PLE (plus the vocabulary expansion to 262,144 tokens, supporting 140+ languages) is the primary architectural delta. The quality jump is substantial — E2B handles multimodal input, produces richer reasoning chains, and degrades more gracefully on complex tasks.

What PLE Means for Quantization

This is the part that most articles skip, and it matters for anyone deploying Gemma 4 on constrained hardware.

The parameter split matters

When you quantize a standard LLM to 4-bit (Q4), you're applying precision reduction uniformly across all parameters — attention weights, FFN weights, and embeddings all get the same treatment. With E2B's PLE architecture, the 2.8B PLE parameters and the 2.3B compute parameters have different sensitivity profiles.

The PLE embedding tables are just lookup arrays — integer indices map to float vectors. They are:

Less sensitive to quantization than attention weights (no gradient flows through them during inference; they're read-only lookups)
Compressible to lower bit-widths without significant quality degradation
Dominant in the model's file size (2.8B out of 5.1B total parameters)

This means you can apply asymmetric quantization: aggressively quantize the PLE tables (say, to 2-bit or 3-bit) while keeping the 2.3B compute parameters at 4-bit or 8-bit precision. The result: smaller file on disk, faster memory loading, minimal quality drop.

Practical RAM targets (approximate, Q4 build)

Quantization	File size	RAM needed	Best for
Q8 (8-bit)	~5.5 GB	~6 GB	Laptops, desktop GPUs
Q4 (4-bit)	~2.8 GB	~3.5 GB	Standard Android phones
Q2 (aggressive)	~1.6 GB	~2.0 GB	Budget phones, Raspberry Pi 5
INT4 mixed (PLE Q2 + compute Q4)	~1.8 GB	~2.3 GB	Embedded systems

The officially stated target of 1.5 GB RAM for E2B refers to an optimized mixed-precision build using LiteRT-LM (Google's edge inference framework). Standard GGUF Q4 builds on Ollama will use slightly more.

Implication for fine-tuning

When fine-tuning E2B (LoRA, QLoRA), the standard practice is to skip embedding layers and focus adapters on attention and FFN weights. With PLE, there's a decision to make: fine-tune the PLE tables or freeze them?

The PLE tables encode general token identity at every layer depth — they're relatively task-agnostic. Freezing them during fine-tuning saves significant VRAM (2.8B frozen parameters) with minimal quality cost for most downstream tasks. Only if your task involves a highly specialized vocabulary (medical jargon, a low-resource language, domain-specific notation) would fine-tuning the PLE tables likely help.

The Bigger Picture: What "Effective Parameters" Really Means

The "E" in E2B and E4B stands for Effective — and PLE is precisely why that distinction exists.

The industry has been obsessed with parameter counts as a proxy for model quality since GPT-3. PLE breaks that proxy in a specific, instructive way. A model can have:

High total parameters → large storage footprint, expensive to download
Low active (compute) parameters → fast inference, low energy use
High representational richness → quality beyond what active-parameter count predicts

These three properties were previously coupled. Mixture-of-Experts (the other 2026 technique) decouples them at the FFN level — only some experts activate per token. PLE decouples them at the embedding level — only the cheap lookup runs per token, not the expensive projection.

Together, MoE and PLE represent a generational shift in how model architects think about efficiency. The question is no longer "how many parameters does the model have?" The correct question is: "how many parameters does the model use on any given forward pass, and what do the rest contribute?"

E2B's answer: 2.3B parameters do the compute work. 2.8B parameters sit in lookup tables and provide layer-specific context signals at almost zero cost. The result is a model that fits in your pocket — literally, on a Pixel phone — while reasoning at a level that would have required a 7B model a generation ago.

Summary: The Mechanism

Standard transformers give each token one embedding at the input. Small models suffer because that single vector carries semantic ambiguity through all layers.
PLE adds a second embedding table. For each token, it produces a small dedicated vector for every decoder layer — pre-computed in a single lookup, sliced and injected per layer.
Each per-layer signal combines token identity with a context-aware component, gated by the current hidden state. The model learns when to refresh token meaning and when it's already resolved.
The PLE tables (2.8B params) are almost free at inference time. They're memory, not compute. This is why E2B stores 5.1B parameters but runs like 2.3B — and punches well above both.

References and Further Reading

Hugging Face Transformers — Gemma 4 Model Documentation (April 2026): Primary source for PLE implementation details, embed_tokens_per_layer structure, and the 1/√2 scaling. https://huggingface.co/docs/transformers/model_doc/gemma4
Hugging Face Blog — Welcome Gemma 4 (April 2, 2026): Official architectural overview of PLE, Dual RoPE, and Shared KV Cache. https://huggingface.co/blog/gemma4
Alan Dao — Gemma 4 E2B & Per-Layer Embeddings: Research Notes (April 5, 2026): Best independent code-level breakdown of PLE, including vocab size analysis and per-layer dimension math. https://alandao.net/posts/gemma-4-e2b-per-layer-embeddings-ple-research-notes/
Botmonster — Gemma 4 Architecture Explained: PLE, Shared KV Cache, and Dual RoPE (April 8, 2026): Clean technical explainer covering all three architectural novelties. https://botmonster.com/posts/gemma-4-architecture-per-layer-embeddings-shared-kv-cache-dual-rope/
Google Technical Overview — Gemma 4 (April 2026): Source for AIME 2026, MMLU Pro, GPQA Diamond, LiveCodeBench, and τ2-bench benchmark numbers. Available via Google DeepMind's model release documentation.
Pebblous — Gemma 4 Deep Dive: Apache 2.0 and Sovereign AI (April 3, 2026): Good coverage of the storage/compute decoupling and quantization implications. https://blog.pebblous.ai/story/google-gemma-4-report-pb/en/
Maarten Grootendorst — A Visual Guide to Gemma 4 (April 3, 2026): Visual explanation of PLE and the broader model family. https://newsletter.maartengrootendorst.com/p/a-visual-guide-to-gemma-4

If you found this useful, I'd love to hear what you're building with E2B in the comments. Are you running it on a phone, an edge device, or something more exotic? The constraint-driven use cases are the interesting ones.

Zero Waste, Zero Stress: Building ReMake with AI-Assisted Github Copilot Development

Shreya Nalawade — Mon, 20 Apr 2026 06:09:31 +0000

🎯 Introduction

What if your discarded cardboard box could become a laptop stand? What if that old denim jacket could transform into a trendy tote bag? Second Life ReMake is an AI-powered upcycling ecosystem that turns household waste into functional treasures.
In this blog, I'll walk you through how I built this app, how GitHub Copilot's Chat and Agent features accelerated development, and why AI-assisted coding is the future of sustainable tech.

🚀 What is Second Life ReMake?

Second Life ReMake is a mobile-first web application that helps users:

📸 Upload images of waste items (broken furniture, old containers, textiles)
🤖 Get AI-powered material analysis (identifies item type, materials, and condition)
🛠️ Receive 5-8 custom DIY upcycling projects tailored to that specific item
📊 Track environmental impact (kilograms of waste diverted from landfills)
🏪 Share creations in a community marketplace

Unlike typical recycling apps that just tell you where to recycle, ReMake shows you how to transform waste into something valuable.

🤝 How GitHub Copilot Helped Build This App

1. Copilot Chat: My Instant Stack Overflow

GitHub Copilot Chat became my interactive coding assistant, answering questions and generating solutions in real-time.

Example: Implementing Image Upload with Preview

My Question in Copilot Chat:

How do I create an image upload component in React that shows a preview 
and converts the image to base64 for API submission?

Copilot's Response:

const ImageUploader = () => {
  const [preview, setPreview] = useState(null);
  const [base64, setBase64] = useState(null);

  const handleImageUpload = (e) => {
    const file = e.target.files[0];
    if (!file) return;

    // Preview
    const reader = new FileReader();
    reader.onloadend = () => {
      setPreview(reader.result);
      setBase64(reader.result.split(',')[1]); // Extract base64
    };
    reader.readAsDataURL(file);
  };

  return (
    <div>
      <input type="file" accept="image/*" onChange={handleImageUpload} />
      {preview && <img src={preview} alt="Preview" />}
    </div>
  );
};

Time Saved: 20 minutes of searching documentation

Bonus: Copilot explained the FileReader API and base64 encoding inline!

2. Copilot Agent: The Autonomous Code Generator

GitHub Copilot's Agent mode (available in VS Code) goes beyond suggestions—it autonomously writes multi-file features based on high-level instructions.

Example: Building the Material Analysis API Integration

My Prompt to Copilot Agent:

Create a function that sends an uploaded image to the Anthropic Claude API, 
analyzes the material composition, and returns structured JSON with:
- item name
- primary materials (array)
- condition score (1-10)
- recyclability rating

What Copilot Agent Generated:

File 1: api/materialAnalysis.js

export async function analyzeMaterial(base64Image) {
  const response = await fetch("https://api.anthropic.com/v1/messages", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "claude-sonnet-4-20250514",
      max_tokens: 1000,
      messages: [
        {
          role: "user",
          content: [
            {
              type: "image",
              source: {
                type: "base64",
                media_type: "image/jpeg",
                data: base64Image
              }
            },
            {
              type: "text",
              text: `Analyze this item for upcycling potential. Return ONLY a JSON object with:
              {
                "itemName": "string",
                "materials": ["material1", "material2"],
                "conditionScore": number (1-10),
                "recyclabilityRating": "Low/Medium/High"
              }`
            }
          ]
        }
      ]
    })
  });

  const data = await response.json();
  const rawText = data.content.find(c => c.type === "text")?.text || "{}";

  // Strip markdown fences if present
  const cleanJson = rawText.replace(/```
{% endraw %}
json|
{% raw %}
```/g, "").trim();
  return JSON.parse(cleanJson);
}

File 2: components/AnalysisResults.jsx

import { useState } from 'react';
import { analyzeMaterial } from '../api/materialAnalysis';

export default function AnalysisResults({ imageBase64 }) {
  const [analysis, setAnalysis] = useState(null);
  const [loading, setLoading] = useState(false);

  const runAnalysis = async () => {
    setLoading(true);
    try {
      const result = await analyzeMaterial(imageBase64);
      setAnalysis(result);
    } catch (error) {
      console.error("Analysis failed:", error);
    }
    setLoading(false);
  };

  return (
    <div>
      <button onClick={runAnalysis} disabled={loading}>
        {loading ? "Analyzing..." : "Analyze Material"}
      </button>

      {analysis && (
        <div className="results">
          <h3>{analysis.itemName}</h3>
          <p>Materials: {analysis.materials.join(", ")}</p>
          <p>Condition: {analysis.conditionScore}/10</p>
          <p>Recyclability: {analysis.recyclabilityRating}</p>
        </div>
      )}
    </div>
  );
}

What Just Happened?

Copilot Agent created 2 files autonomously
Added error handling and loading states
Implemented JSON parsing with sanitization (removes markdown fences)
Time saved: 45+ minutes

3. Copilot Inline Suggestions: The Silent Productivity Booster

While coding, Copilot's inline suggestions completed entire functions based on context.

Example: Generating Upcycling Projects

What I Typed:

// Generate 5-8 unique DIY upcycling projects for the analyzed item
async function generateUpcyclingProjects(itemAnalysis) {

What Copilot Autocompleted:

async function generateUpcyclingProjects(itemAnalysis) {
  const response = await fetch("https://api.anthropic.com/v1/messages", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "claude-sonnet-4-20250514",
      max_tokens: 2000,
      messages: [
        {
          role: "user",
          content: `Given this item analysis:
          ${JSON.stringify(itemAnalysis)}

          Generate 5-8 creative DIY upcycling projects. For each project, provide:
          - Project name
          - Difficulty (Easy/Medium/Hard)
          - Materials needed (array)
          - Estimated time (string)
          - Step-by-step instructions (array)
          - Waste diverted (kg)

          Return as JSON array.`
        }
      ]
    })
  });

  const data = await response.json();
  const rawText = data.content.find(c => c.type === "text")?.text || "[]";
  const cleanJson = rawText.replace(/```
{% endraw %}
json|
{% raw %}
```/g, "").trim();
  return JSON.parse(cleanJson);
}

I literally pressed Tab 7 times. That's it. Copilot understood:

The API structure from my previous code
The need for JSON sanitization
The output format based on the comment

Copilot's Diagnosis:

You're mutating state directly in your useEffect. React won't detect the change.

Change this:
  userData.projectsCompleted += 1;

To this:
  setUserData(prev => ({
    ...prev,
    projectsCompleted: prev.projectsCompleted + 1
  }));

Instant fix. No Stack Overflow rabbit hole.

📊 Development Velocity: Before vs. After Copilot

Task	Without Copilot	With Copilot	Time Saved
API Integration	2 hours	25 minutes	78%
Image Upload Component	45 minutes	10 minutes	78%
State Management Setup	1 hour	15 minutes	75%
Debugging React Hooks	30 minutes	5 minutes	83%
TOTAL PROJECT TIME	~40 hours	~12 hours	70%

🎨 The Full Tech Stack

Frontend:  React + Tailwind CSS
Backend:   Firebase
Auth:      Google Sign-In
Storage:   LocalStorage (expandable to Firebase)
Hosting:   Vercel
AI Tools:  GitHub Copilot (Chat + Agent + Inline)

📝 Key Features Built with Copilot's Help

1. Smart Image Upload System

Device camera/gallery integration
Real-time preview with grayscale filter
Base64 encoding for API transmission

2. AI Material Analysis Engine

Multi-modal Claude API integration
Structured JSON response parsing
Material composition breakdown

3. Dynamic Project Generator

Context-aware DIY suggestions
Difficulty rating system
Resource list compilation
Impact calculation (waste diverted in kg)

4. Progress Dashboard

Achievement badge system
Real-time waste diversion counter
Level progression tracking

5. Community Marketplace

Local upcycled item browsing
Category filtering (Fashion, Home, Furniture)
Item inspection modal

🧠 Lessons Learned: Maximizing Copilot's Potential

✅ DO:

Write descriptive comments before functions—Copilot uses them as instructions
Ask Copilot Chat for architecture advice before coding
Use Agent mode for multi-file features
Review generated code—Copilot is smart but not infallible

🌍 Real-World Impact

Since deploying the beta:

250+ items analyzed
180 kg of waste diverted from landfills
92% user satisfaction with AI-generated projects
Average completion rate: 67% (users actually finish the DIY projects!)

📦 Try It Yourself

GitHub Repo: Github
Video Link:

Deploy Link: https://remake-kappa.vercel.app/

📦 PRIZE CATEGORIES - BEST USE OF GITHUB COPILOT

🤝 Join the Movement

Have a waste item you want to transform? Try Second Life ReMake and tag us with #Upcycling

Let's code a cleaner planet, one upload at a time. 🌱

Build a Website Using S3 and CloudFront with Terraform

Shreya Nalawade — Wed, 28 Jan 2026 15:13:04 +0000

Introduction

Imagine you are part of a company preparing to launch a short but intense marketing campaign for a new product. Thousands of visitors are expected to land on the website within a short time frame. Your manager asks you to design a hosting architecture that is fast, secure, and affordable.

In this guide, we focus on the infrastructure design rather than the website content itself. The goal is to choose the right AWS services and deploy them using Terraform.

Key Requirements

Before selecting any technology, we must understand the constraints:

The campaign will only run for a limited time.
Traffic volume is unpredictable, but could reach thousands of users per day.
Protection against DoS and DDoS attacks is critical.
The solution must remain cost-effective.
Users should experience fast load times regardless of their geographic location.

Choosing the Hosting Platform

To satisfy global reach and performance, AWS provides two ideal services:

Amazon S3 for storing and serving static website files
AWS CloudFront as a global content delivery network (CDN)

Together, these services create a scalable and highly available solution.

Architecture Diagram

This diagram shows how users access CloudFront, which retrieves content from an S3 bucket and delivers it through edge locations.

Why Terraform?

Terraform allows infrastructure to be defined in code and deployed automatically.

Using Terraform ensures that infrastructure is:

Reproducible
Version-controlled
Easy to audit and modify

Instead of repeatedly configuring resources in the AWS Console, we write declarative code and deploy everything with simple CLI commands.

Terraform Template Example

resource "random_string" "bucket_rs" {
  count   = var.s3_count
  length  = 4
  special = false
  upper   = false
}

resource "aws_s3_bucket" "exos_bucket" {
  count  = var.s3_count
  bucket = join("-", ["exos-bucket", random_string.bucket_rs[count.index].result])
  acl    = "public-read-write"
}

resource "aws_cloudfront_distribution" "exos_distribution" {
  count = var.s3_count

  origin {
    domain_name = aws_s3_bucket.exos_bucket[count.index].bucket_regional_domain_name
    origin_id   = "exos_distribution"

    custom_origin_config {
      http_port              = 80
      https_port             = 443
      origin_protocol_policy = "match-viewer"
      origin_ssl_protocols   = ["TLSv1", "TLSv1.1", "TLSv1.2"]
    }
  }

  enabled             = true
  default_root_object = "index.html"

  default_cache_behavior {
    viewer_protocol_policy = "redirect-to-https"
    compress               = true
    allowed_methods        = ["GET", "HEAD", "OPTIONS", "PUT", "POST", "PATCH", "DELETE"]
    cached_methods         = ["GET", "HEAD"]
    target_origin_id       = "exos_distribution"

    min_ttl     = 0
    default_ttl = 86400
    max_ttl     = 31536000

    forwarded_values {
      query_string = false
      cookies {
        forward = "none"
      }
    }
  }

  price_class = "PriceClass_All"

  restrictions {
    geo_restriction {
      restriction_type = "whitelist"
      locations        = ["US", "CA", "GB", "DE"]
    }
  }

  viewer_certificate {
    cloudfront_default_certificate = true
  }
}

Understanding CloudFront

AWS CloudFront is a content delivery service that caches and distributes data from locations close to end users.

CloudFront improves performance by delivering:

Images
Videos
Static files (HTML, CSS, JS)

from global edge locations instead of a single origin server.

Built-in Security Features

Automatic DDoS mitigation
Support for Origin Access Identity (OAI)
Country-based access controls (geo-restriction)

This makes CloudFront both a performance and security layer in front of S3.

Understanding Amazon S3

Amazon S3 is an object storage service designed for durability and massive scale.

S3 can also function as a static website host by serving files such as:

HTML
CSS
JavaScript

This removes the need to manage traditional web servers like Apache or Nginx, reducing both complexity and cost.

Why S3 + CloudFront?

When a user accesses your website:

The request goes to CloudFront.
CloudFront checks its cache.
If content is missing, it fetches it from S3.
The content is cached and delivered to the user.

Benefits

Fast global CDN delivery
Low-cost storage
Free data transfer from S3 to CloudFront
Strong built-in security

Step-by-Step Implementation

Step 1: Install Terraform

terraform -v
terraform init

Step 4: Validate Configuration

terraform validate

Step 5: Deploy Infrastructure

terraform apply

Step 6: Upload Website Files

aws s3 sync ./website s3://your-bucket-name

Step 7: Access via CloudFront

https://<distribution-id>.cloudfront.net

Conclusion

Amazon S3 and CloudFront work together to provide a powerful platform for hosting static websites. This combination delivers:

Global performance
Built-in security
Low operational cost

The architecture can be further improved by integrating:

AWS WAF
AWS Shield
Amazon Route53

Terraform makes it easy to deploy, destroy, and reproduce this environment across multiple stages such as development, testing, and production.

Kiro: Instant Finance & Expense Tracking

Shreya Nalawade — Sun, 04 Jan 2026 18:04:44 +0000

A lightweight finance and budget calculator built using Kiro, designed to help users quickly calculate expenses, track budgets, and understand their financial status in a fraction of a second.

This project is intentionally kept simple and beginner-friendly, making it ideal for learning Kiro, building demos, or showcasing how Kiro’s chat-based intelligence can power practical applications.

📌 Overview

Managing finances does not always require complex accounting software. Many users simply need a fast way to:

Enter a budget
Add expenses
See how much they have spent
Know how much money is left

Kiro – Simple Finance & Budget Calculator solves exactly this problem using a clean UI and Kiro’s AI-driven chat assistance.

✨ Features

Budget Input – Enter a total budget or income
Expense Tracking – Add multiple expenses with name and amount
Instant Calculations
- Total expenses
- Remaining balance
Overspending Detection – Alerts when expenses exceed the budget
Kiro Chat Interface – Ask finance questions in natural language
Minimal & Clean UI – Easy to understand for all users

🛠️ Tech Stack

Kiro – AI assistant and chat logic
JavaScript / HTML / React
Node.js
python

Note: This project focuses on logic simplicity rather than heavy backend architecture.

⚙️ Installation & Setup

1️⃣ Prerequisites

Node.js (v16 or above recommended)
npm or yarn
Kiro account

2️⃣ Install Kiro

Follow the official Kiro getting started guide:

🔗 kiro docs

3️⃣ Clone the Repository

git clone https://github.com/Shreya111111/tracker-kiro

▶️ How It Works

User enters a budget amount
User adds individual expenses
Processes the data instantly
App calculates:

Total expenses
Remaining balance
1. Results are displayed clearly on the screen

How Kiro Helps

Understands user intent
Performs calculations accurately
Responds with simple, human-readable answers

💬 Using Kiro Chat & Spec for Design & Implementation Phases

Kiro Chat was used throughout this project as a design-thinking and implementation assistant, helping move step by step from idea to a working finance and budget calculator.

Instead of directly writing all logic or UI upfront, the development followed phased guidance using Kiro Chat, as recommended in Kiro’s official workflow approach.
Core Components of a Kiro Spec
Kiro typically generates three primary markdown files for every new feature or project to ensure alignment between requirements and code:

requirements.md: Captures user stories and acceptance criteria, often using EARS (Easy Approach to Requirements Syntax) notation to make intent explicit and testable.
design.md: Documents the technical architecture, including sequence diagrams (often via Mermaid) and data flow models.
tasks.md: Provides a detailed, trackable implementation plan. Kiro breaks the design into discrete tasks that agents can execute one by one

🧠 Phase 1: Problem Understanding & Scope Definition

The first step was to clearly define what the app should and should not do.

Kiro Chat Usage

Example prompts used:

Help me define a finance and budget calculator for beginners
What features should a basic budget calculator include?
What should I avoid to keep the app simple?

Outcome

Clear scope defined
No complex finance rules
Focus on budget, expenses, and balance only

This aligns with Kiro’s guidance to start with clarity before implementation.

🎨 Phase 2: UI / UX Design Assistance

Kiro Chat was then used to assist with basic UI planning.

Kiro Chat Usage

Example prompts:

Suggest a UI layout for a budget calculator
What input fields are required for this app?
How should results be displayed clearly?

Outcome

Budget input field
Expense name + amount inputs
Summary section for totals
Minimal, clean layout

Kiro helped translate functional requirements into simple UI components.

🧩 Phase 3: Logic & Calculation Design

Before coding, Kiro Chat was used to validate the calculation logic.

Kiro Chat Usage

Example prompts:

How to calculate total expenses and remaining budget?
What happens if expenses exceed the budget?
Explain the logic in simple steps

Outcome

Clear calculation flow
Overspending condition defined
Easy-to-implement logic

This phase reduced errors before implementation.

💻 Phase 4: Implementation Support

During development, Kiro Chat acted as a real-time coding assistant.

Kiro Chat Usage

Example prompts:

Help me write simple logic for adding expenses
How to update total dynamically when a new expense is added?
Explain this code in simple terms

Outcome

Faster implementation
Cleaner logic
Better understanding of each step

💬 Phase 5: Chat-Based User Interaction

Kiro Chat was also integrated as a user-facing feature.

Example User Queries

What is my total expense?
How much budget is left?
Am I overspending?
Summarize my expenses

Kiro interprets these queries and responds with calculated results in plain language.

🔁 Phase 6: Review & Refinement

Finally, Kiro Chat was used to:

Review app flow
Identify missing edge cases
Suggest small UX improvements

Example prompts:

Review my budget calculator flow
What improvements can make this more user-friendly?

✅ Alignment with Kiro Best Practices

As referenced from the Kiro official documentation and guides, this phased approach follows:

Clear problem definition
Iterative design
Incremental implementation
Continuous validation using chat

Kiro Chat proved effective not just for coding, but for thinking, designing, and refining the application end to end.

📸 Screenshots

Attached screenshots

Budget input screen
Expense entry screen
Expense summary
Kiro chat interaction

📂 Project Structure

kiro-finance-budget-calculator/
├── kiro.
├── vscode/
├── index.html
├── script.js
├── styles.css
└── README.md

🔗 GitHub Repository

🔗 Repo Link

🎯 Use Cases

Personal monthly budgeting
Student expense tracking
Kiro learning project
Demo or hackathon submission
Proof of concept for AI-powered calculators

🚀 Added features

Expense categories (Food, Rent, Travel, etc.)
Monthly history tracking
Visual charts
Mobile-friendly UI

🤝 Contributing

Contributions are welcome!

Fork the repository
Create a feature branch
Commit your changes
Open a pull request

If you found this project useful, please ⭐ the repository and share your feedback!

KendoManage - Personal Task Scheduler & Manager( 30+ Kendo components + Built using KendoReact AI Code assistant)

Shreya Nalawade — Sun, 28 Sep 2025 18:16:30 +0000

This is a submission for the KendoReact Free Components Challenge.

What I Built

🚀 What I Built

I created KendoManager, a 🌟 feature-rich, enterprise-grade project management & collaboration platform with modern UI/UX patterns. Here's what it offers:

📋 Task Management: Create, edit, delete tasks; track progress 📊; assign priorities 🔝; attach files 📎; manage due dates 🗓️; support parent-child tasks 🌱.
👥 Team Collaboration: Real-time member status 🟢🟡🔴; task-based comments 💬; @mentions with notifications 🔔; team profiles 🧑‍💼.
📅 Calendar & Scheduling: Event scheduling 🕒; multiple calendar views 🗓️; date marking 🎯; visual analytics 📈.
📊 Analytics & Reporting: Task distribution charts 📊; monthly trends 📅; KPI tracking 🎯; interactive dashboards 🖥️.
📂 File Management: Upload/download files ⬆️⬇️; categorize and search files 🔍; share files with team members 🤝.

All of this is built using 30+ KendoReact components 🎨, ensuring a polished, interactive, and scalable experience 💻✨.

⚡ Parts of the UI scaffolding were generated and refined using the Kendo AI Coding Assistant 🤖, speeding up development and improving code quality.

Demo

Source Code : https://github.com/Shreya111111/Kendomanager_new
Demo Live Link : https://kendomanager-new.vercel.app/

KendoReact Components Used

📦 KendoReact Components & Installation Commands(30+ KendoUI free components used)

Category	Components	Installation Command
Data Management	`Grid`, `GridColumn`	`npm install @progress/kendo-react-grid @progress/kendo-data-query @progress/kendo-react-intl`
Charts & Visualization	`Chart`, `ChartSeries`, `ChartSeriesItem`, `ChartCategoryAxis`, `ChartCategoryAxisItem`	`npm install @progress/kendo-react-charts hammerjs`
Form Controls	`Button`, `Input`, `TextArea`, `Switch`, `Slider`, `Form`, `Field`	`npm install @progress/kendo-react-buttons @progress/kendo-react-inputs @progress/kendo-react-form`
Dropdowns & Selection	`DropDownList`, `MultiSelect`, `ComboBox`, `AutoComplete`	`npm install @progress/kendo-react-dropdowns`
Date & Time	`Calendar`, `DatePicker`, `DateRangePicker`, `Scheduler`	`npm install @progress/kendo-react-dateinputs @progress/kendo-react-scheduler`
Layout & UI	`Card`, `CardBody`, `CardTitle`, `Avatar`, `Badge`, `Dialog`, `TabStrip`, `TabStripTab`	`npm install @progress/kendo-react-layout @progress/kendo-react-dialogs @progress/kendo-react-indicators`
Indicators	`ProgressBar`, `Badge`	`npm install @progress/kendo-react-progressbars @progress/kendo-react-indicators`
File Handling	`Upload`	`npm install @progress/kendo-react-upload`

🔑 Notes

All KendoReact packages require installing KendoReact Base & Styling:

npm install @progress/kendo-react-intl @progress/kendo-theme-default

Prize Code Smarter, Not Harder prize category- AI Coding Assistant Usage

🔧 Installation

To integrate the KendoReact AI Coding Assistant into my development environment, I followed these steps:

Set Up a React Application: I created a new React project using Vite:

   npm create vite@latest kendo-manager
   cd kendo-manager
   npm install

Install KendoReact Components: I installed the necessary KendoReact components for UI elements:
npm install @progress/kendo-react-grid @progress/kendo-react-charts @progress/kendo-react-inputs @progress/kendo-react-buttons @progress/kendo-react-dropdowns @progress/kendo-react-dateinputs @progress/kendo-react-scheduler @progress/kendo-react-layout @progress/kendo-react-dialogs @progress/kendo-react-progressbars @progress/kendo-react-upload @progress/kendo-react-intl @progress/kendo-theme-default

Install the AI Coding Assistant: I added the KendoReact AI Coding Assistant to enhance development efficiency:

npm install @progress/kendo-react-mcp

Configure the AI Coding Assistant: I integrated the assistant into my development environment, enabling it to provide context-aware code suggestions and enhancements.

🧠 Usage

The KendoReact AI Coding Assistant significantly improved my development workflow in the following ways:

Initial Code Generation: It helped me quickly scaffold components like Grids, Forms, and Charts, allowing for rapid prototyping and development.
Component Configuration: The assistant provided guidance on configuring complex components, such as setting up multi-column headers in Grids or configuring recurring events in the Scheduler.
Data Binding Assistance: It assisted in binding dummy data to components for testing and prototyping purposes, streamlining the development process.
Step-by-Step Explanations: The assistant offered detailed explanations of the code snippets it generated, helping me understand the implementation and learn best practices.
Troubleshooting: It provided preliminary solutions to common issues, saving time on debugging and problem-solving.

Screenshots of KendoReact AI coding Assistant

What I Liked in the KendoReact AI Coding Assistant

⚡ Accelerated Component Development:
The AI assistant rapidly generates code for various KendoReact components, enabling faster prototyping and reducing time spent on boilerplate code.
🎯 Expert Configuration Guidance:
It provides detailed assistance with complex component configurations, such as setting up multi-column headers in Grids and managing advanced Scheduler features.
🔗 Simplified Data Binding:
The assistant streamlines the process of binding data to components, making it easier to set up testing environments and prototypes quickly.
📚 Clear Code Explanations:
It offers step-by-step breakdowns of generated code, helping developers understand implementation details and best practices more effectively.
🔧 Efficient Troubleshooting:
By providing preliminary solutions to common issues, the assistant reduces debugging time and helps resolve problems faster.

Iris- Your AI Interviewer(Audio+ Visual+ Live Cam+ Feedback)🎙️📹✨

Shreya Nalawade — Sun, 14 Sep 2025 16:40:10 +0000

This is a submission for the Google AI Studio Multimodal Challenge

💡 What I Built

Iris is an AI-powered Interview Coach designed to help candidates practice, improve, and excel in interviews.
Instead of reading generic interview guides, Iris creates a personalized interview experience by combining resume understanding, live camera interaction, and structured feedback — powered by Google AI Studio (Gemini multimodal models).

It feels just like a face-to-face mock interview with a professional hiring manager, but available anytime, anywhere.

🌟 Iris Features

📄 Resume Scan – Upload PDF/image, extracts key skills, experience, education & generates a concise summary.
🎤 Live AI Interview – Face-to-face AI interviewer with camera & mic, adapting questions to your resume & responses.
🤖 Personalized Feedback & Coaching – Gets strengths, areas to improve, and STAR method evaluation from your session.
💾 Download Feedback Report – Save detailed feedback as a document.
🔗 Share Progress – Share reports with friends/mentors for collaborative review.
📜 Interview History – Timeline of past interviews with scores & feedback summaries.
📂 Previous Transcripts – View transcripts with questions & answers to track progress over multiple sessions.

🎥 Demo

👉 Video

Note : You might be not able to hear AI Voice in the video because my system is not able to catch system audio when doing screen recording because of some issue. I am attaching the deployed link below so that you can try it out yourself. All you have to do is upload the resume(PDF) format. Avoid using app repeatedly at a particular time frame as it might exhaust the API credits.

Deployed Cloud Run Link : https://iris-your-ai-interviewer-47821800150.us-west1.run.app/

Screenshots

App Source Code : Link

🧑‍💻 Features in Detail
1. 📄 Resume Scan + AI Summary

Upload your resume as a PDF or image.

Iris uses Gemini multimodal capabilities to extract:

✅ Key skills
✅ Experience highlights
✅ Education & certifications
Generates a concise summary to guide the interview.

2. 🎤 Live AI Interview (Audio + Visual + Camera)

Iris acts as a virtual interviewer.
You interact face-to-face using your camera and microphone.
The AI adapts its questions to your resume and responses.
Covers both behavioral (STAR method) and technical questions.

3. 🤖 Personalized Feedback & Coaching

After the session, Iris analyzes the entire transcript.

Feedback includes:
🌟 Strengths (clarity, confidence, relevance)
📌 *Areas to Improve *(with actionable advice)
🎯 STAR Method Evaluation (Situation, Task, Action, Result)
Output is structured, easy to understand, and encouraging.

4. 📑 Save & Share Your Progress

💾 Download Feedback Report as a document.

🔗 Share with friends/mentors for collaborative review.

📜 Include Interview History

Show a timeline of past interviews:
Date & time of each interview
Overall score or feedback summary

📂 Include Previous Interview Transcripts

Provide transcripts or summaries of past interviews
Questions asked
Candidate answers Helps track progress across multiple practice sessions.

🛠️ How I Used Google AI Studio

Iris is powered by Gemini multimodalfeatures:

Resume Parsing (File + Text Input)
Uses gemini-2.5-flash to extract structured insights from resumes.
Interview Simulation (Chat API)
Creates a dynamic chat session where Gemini acts as a hiring manager.
Feedback Analysis (JSON Schema)
Ensures structured responses:

{
  "strengths": ["Good clarity", "Relevant examples"],
  "areasForImprovement": ["Expand on technical depth", "Use STAR format"]
}

📦 Gemini Services Used

1. gemini-2.5-flash ⚡

Why used:

Fastest multimodal Gemini model.
Handles resume parsing from PDFs/images quickly.
Great for interactive chat-based interviews where low latency is critical.

import { GoogleGenAI, Chat, Type } from "@google/genai";


✅ generateContent() → Resume extraction + feedback generation

✅ chats.create() → Interactive interview simulation

✅ JSON schema → Well-structured coaching insights

🚀 Why Iris?

🎯 Problem: Many candidates struggle with interview preparation — either they don’t know what to expect or lack constructive feedback.
🌟 Solution: Iris provides a safe, intelligent, and supportive environment to practice, with AI that:
Understands your resume
Conducts live interviews
Gives actionable coaching feedback
Helps you improve over time
With Iris, you no longer have to walk into an interview unprepared.

Atomica- Turn Science into understandable concepts (Audio+Visual+ Tutoring)

Shreya Nalawade — Sun, 07 Sep 2025 08:33:49 +0000

This is a submission for the Google AI Studio Multimodal Challenge

What I Built

Atomica is an AI-powered educational app that transforms science learning into an interactive, visual, auditory, and engaging experience. It helps students understand complex concepts through diagrams, explanations, quizzes, flashcards, AI-powered tutoring, and audio narration. By combining multimodal AI capabilities, Atomica addresses the common problem of abstract science topics being hard to visualize, understand, and memorize, creating a hands-on, multisensory learning experience for students of all ages.

Atomica User Input

👤 Your Level

Who are you learning for?

🧒 Kid
🎓 High School Student
🎓👩‍🎓 College Student

🔬 Scientific Concept

Type the science topic you want to learn:

Examples: Photosynthesis, Newton’s Laws, DNA replication

🌐 Language

Choose the language you want:

🇬🇧 English
🇮🇳 Hindi
🇫🇷 French
🇩🇪 German
🇪🇸 Spanish

📚 Learning Mode

How do you want to learn?
🖼️ Diagrams & visuals
🎧 Audio explanations
📝 Quizzes & flashcards
🤖 AI tutor guidance

Demo

Demo Link

Deployed Cloud Run App: Atomica Live Demo

Screenshots

How I Used Google AI Studio

1. Diagram Generation

What it does: Converts a text prompt (like “Photosynthesis” or “Black Hole”) into a visual diagram.
How it works: Uses AI to generate a clean, modern, educational illustration, highlighting only the key components with minimal text.
Why it’s valuable: Makes abstract scientific concepts visible and easier to understand, helping visual learners quickly grasp ideas that are otherwise hard to imagine.

2. Multimodal Explanations

What it does: Provides explanations based on the generated diagrams, combining both visual and textual information.
How it works: AI analyzes the diagram and the topic prompt, then generates a concise, context-aware explanation. It can also use analogies for easier understanding.
Why it’s valuable: Supports deep comprehension, allowing learners to connect the visual information to the underlying science in a meaningful way.

3. Audio Narration

What it does: Reads explanations aloud to students.
How it works: Uses AI to generate natural-sounding speech from the text explanations.
Why it’s valuable: Supports auditory learners and makes the platform accessible to students with visual impairments. It also allows multitasking or studying on the go.

4. Interactive Q&A (AI Chat Tutor)

What it does: Allows students to ask follow-up questions about any topic.
How it works: AI uses the context of the explanation and diagram to provide relevant, accurate answers in real time.
Why it’s valuable: Creates a personalized learning experience, helping students clarify doubts instantly instead of waiting for a teacher or searching elsewhere.

5. Quiz and Flashcard Generation

What it does: Automatically creates multiple-choice quizzes and flashcards from the explanation text.
How it works: AI extracts key concepts and formulates questions, answers, and concise definitions for flashcards.
Why it’s valuable: Encourages active recall and spaced repetition, which are proven techniques for memory retention and mastery of concepts.

6. Translation Support

What it does: Converts explanations, quizzes, and flashcards into multiple languages.
How it works: AI translates text while maintaining clarity and scientific accuracy.
Why it’s valuable: Makes learning accessible to non-English speakers and supports global users, expanding the app’s usability and reach.

✅ Summary

Together, these features make Atomica a complete multisensory learning platform. Students can:

See diagrams,
Read and hear explanations,
Test themselves with quizzes and flashcards,
Interact with an AI tutor, and
Learn in multiple languages, all in one place.

Multimodal Features

Image Generation: The imagen-4.0-generate-001 model is used to generate clear, educational diagrams from text prompts. Note that this model may require a paid tier, and free-tier access may not be available.
Multimodal Explanation: The gemini-2.5-flash model analyzes both diagrams and text prompts to provide context-aware explanations, making complex science concepts easy to understand. This is fully supported in the free tier.
Quiz Generation: Also using gemini-2.5-flash, Atomica automatically generates multiple-choice quizzes based on the explanations, helping students test their understanding. Free-tier usage is supported.
Flashcards: The same gemini-2.5-flash model creates memorization flashcards for key concepts, aiding active recall and long-term retention. Free-tier access is available.
Chat Tutor: gemini-2.5-flash powers the interactive Q&A feature, allowing students to ask follow-up questions and receive accurate, context-aware answers. This feature is supported on the free tier.
Translation: Using gemini-2.5-flash, Atomica can translate explanations, quizzes, and flashcards into multiple languages, expanding accessibility for global learners. Free-tier usage is supported.

🎯 9-to-Alive: The Intranet Homepage Reinvented with Axero’s Vision

Shreya Nalawade — Sun, 20 Jul 2025 16:06:05 +0000

This is a submission for Frontend Challenge: Office Edition sponsored by Axero, Holistic Webdev: Office Space
"Where employees go to get things done."

Inspired by Axero's core principles—Productivity, Collaboration, Beautiful UI, People-Centric Design, and Instant Access to Information—this intranet homepage brings together purpose, aesthetics, and smart interactivity.

What I Built

🌟 Main Features Overview
🎯1. Smart Navigation & UX

Sticky Tab Navigation that follows the user as they scroll.

Keyboard Shortcuts for instant access:

⌘+H – HR Portal
⌘+I – IT Help Desk
⌘+T – Timesheets
⌘+S – Team Chat
Notification Badges for unread announcements or messages.
Animated Active Tab Indicators and toast notifications.

🗂️ Interactive Core Tabs
📅 2. Events Tab

"Plan, RSVP, and participate with ease."
RSVP-enabled interactive event cards with hover details.
Advanced filtering by type: Meetings, Lunches, Hackathons, Holidays.
Real-time search with suggestions.
Event creation modal + notification system.

👥 3. Teams Tab

"Know your people. Celebrate them."
Expandable team member profiles with click-to-reveal contact info.
Department filters and search.
Work anniversary trackers and online/offline status indicators.
“Connect” and “Message” buttons with animations.

📁 4. Resources Tab

"Everything you need. Instantly."
Downloadable documents with rating system.
Bookmark functionality using localStorage.
Sorting by name, downloads, rating, date.
Category and tag filters.

📢 5. Announcements Tab

"Stay informed, stay ahead."
Priority levels: Urgent, High, Medium, Low.
Visual indicators for read/unread.
Like/comment system.
Search + category filter.
“Mark as Read” notifications.

⭐ 6. Highlights Tab

"Capture moments that matter."
Achievements, milestones, and news in visual cards.
Masonry layout for a beautiful gallery effect.
Persistent like/bookmark features.
Sharing and reactions.

🎮7. Interactive Games Tab: Gamified Learning Center

🧠 Company Trivia Game

Timed Q&A with:
Score tracking
Global leaderboard
Confetti for high scores
Progress indicators and question explanations

🧩 Memory Challenge

Classic card matching gameplay.
Score, move counter, reset.
LocalStorage for personal score tracking.
Confetti celebration on completion.
Bonus: Global leaderboard for friendly competition!

🔋 Enhanced Interactivity & Persistence

Real-time Feedback: Toasts, micro-interactions, hover states.
Confetti Animations: For achievements and game completions.
LocalStorage Integration:
Bookmarks, likes
Announcements read status
Game scores
Mood check-in data

💼Axero Signature Widgets

🏆 8. Team Spotlight (Axero Core Feature)

"Celebrate excellence and foster culture."
Employee of the Month (e.g. Sarah Chen – Senior Developer, Engineering)
Click to appreciate (heart or kudos system)
Highlights major contributions (e.g. “Outstanding performance in Q4 2024”)

📈 9. Project Dashboard

"Track progress. Deliver with confidence."
Projects with:
Status indicators (active, overdue)
Due dates and percentage completion
Assigned team member avatars

Examples:

Customer Portal v2.0 – 75%
Mobile App Redesign – 45%
API Security Audit – 90%, Overdue

💬 10. Daily Check-in & Leadership Corner
"Prioritize mental wellbeing. Hear from leadership."

Daily Mood Check-in: Emoji-based (Happy, Okay, Stressed)
Personalized response messages - Stored in localStorage for trend tracking
Tip card: "Regular check-ins help us improve your work experience."
Leadership Corner:
Weekly message from CEO/Managers

Example:

“Excited to announce our Q4 results exceeded expectations! Thank you all for your incredible dedication.”
– Jennifer Walsh, CEO

🎯 Principle of the Day

"Be Customer-Obsessed: Every decision should benefit our customers first."
Auto-rotating display of Axero’s core principles.
Smooth transitions every 10 seconds using JS.

💌 Kudos Wall

"Shoutouts that shape culture."
Peer-to-peer appreciation board
Like system (❤️)
Timestamped kudos with sender & receiver cards

Demo

Live Demo

Explore the full interactive intranet experience here: Link

Shreya111111 / Intranet1

🎯 9-to-Alive: The Intranet Homepage Reinvented with Axero’s Vision

Welcome to Office Haven — a modern, people-first digital workspace crafted to elevate team collaboration, boost morale, and make workdays more intuitive, engaging, and productive.

🌐 Live Demo: Check it out on Netlify!

💡 Features at a Glance

🔧 Feature	📝 Description
📅 Live Events	RSVP-enabled event tiles with countdowns & speaker highlights.
🧠 Knowledge Center	Searchable documentation, team resources, and SOPs.
🎮 Gamification Hub	Badge rewards, levels, and XP-based interactions.
🌈 Mood Check-ins	Anonymous emoji-based status updates to support mental wellness.
🌟 Team Spotlights	Auto-rotating member highlights to boost morale and visibility.
📢 Announcement Carousel	Company-wide updates in a rotating banner format.
🔍 Quick Links Panel	Instant access to HR tools, payroll, IT support, and more.
📈 Productivity Dashboard	Track daily goals, completed tasks, and focus timers.
🤝 Collaboration Feed	Shout-outs, polls, and quick wins posted by the team.

…

View on GitHub

Journey

Designing Office Haven was an exciting opportunity to reimagine what a modern intranet could be. I focused on combining Axero’s core principles with engaging interactivity, ensuring a people-first experience that’s both functional and fun. From implementing 📅 live RSVP-enabled events to building a 🎮 gamified center and 😊 mood check-ins, each feature was crafted to promote productivity and culture. The result is a digital workspace that feels alive, intuitive, and truly collaborative.

🛠️ My process began with deep research into Axero’s core values and product philosophy, which helped guide every 🧩 design and interaction choice. I 🧾 wireframed the layout to prioritize ease of navigation and 🔍 information accessibility, then built the interface using clean, modular code. ✨

License : MIT ❤️

Made in ❤️ by Shreya N

AI E-CommerceWatch – Product Research Agent for E-Commerce By RunnerH

Shreya Nalawade — Thu, 19 Jun 2025 16:36:06 +0000

This is a submission for the Runner H "AI Agent Prompting" Challenge

What I Built

I created an AI-powered autonomous product research agent using Runner H, focused on helping e-commerce sellers identify high-potential products for platforms like Amazon, Etsy, and Shopify.

This Runner H agent performs:

Trend analysis across platforms (Amazon, TikTok Shopping, Google Trends)
Product data aggregation (prices, reviews, profit margins)
Competition scoring
Supplier discovery
Launch strategy generation

All of this is saved in a structured PDF and Google Sheet for actionable insights.

Demo

Prompt Used

Agent Objective:
You are an AI Agent designed to help Amazon sellers identify profitable product opportunities by scanning e-commerce trends, evaluating market demand and competition, and shortlisting suppliers.

Inputs Required:
- A keyword or niche idea (e.g., “portable blender”, “eco-friendly yoga mat”)
- Minimum profit margin (%)
- Minimum monthly search volume
- Maximum competition threshold (scale of 1–10)
- Target region (e.g., US, India)

Tasks:
1. Trend Research:
   - Search Amazon, Google Trends, Etsy, and TikTok Shopping to evaluate the popularity of the keyword.
   - Capture top 5 trending related keywords.
   - Summarize seasonality insights if any (e.g., spikes during summer).

2. Market Evaluation:
   - Find 5 top-selling listings on Amazon for the keyword.
   - Collect price, estimated monthly sales, reviews, rating, and fulfillment type (FBA, FBM).
   - Calculate rough profit margin: (Price – Est. Cost) / Price.
   - Flag products meeting the margin & volume criteria.

3. Competition Analysis:
   - Count total number of sellers.
   - Analyze top 3 sellers’ review counts.
   - Estimate barrier to entry (low/medium/high).
   - Score the competition level from 1–10.

4. Supplier Discovery:
   - Search Alibaba or IndiaMART for potential suppliers.
   - List top 3 suppliers with MOQ, cost per unit, and contact info.

5. Launch Plan Generation:
   - Recommend pricing strategy.
   - Suggest 3 key differentiators or features.
   - Suggest initial launch platform (Amazon, Etsy, own store).
   - List recommended ad budget and keywords.

Youtube Link

RUNNER H LINK : Prompt Link
Outputs:

Write all outputs in a structured PDF with fields matching the Google Sheet schema below.

Generated PDF
AI Market Analysis - Google Sheets

How I Used Runner H

Workflow Structure

Input Collection
User enters a niche or product idea (e.g., "phone")
Trend Analysis (Runner H agent)
Scrapes Amazon bestsellers, Google Trends, TikTok Shopping
Extracts seasonality, rising interest, top keywords
Market Evaluation
Collects top listings from Amazon (price, reviews, rating)
Estimates profit margin, average monthly sales
Assigns a competition score
Supplier Sourcing
Pulls top matches from Amazon / IndiaMART with MOQ and pricing
Launch Strategy Generator
Recommends pricing, ad budget, key differentiators, and best platform
Data Export

All data saved to a structured Google Sheet: AI Market Watch – Q2

Use Case & Impact

Who it helps:

Indie e-commerce founders
Amazon FBA sellers
Product researchers
DTC brands

What it solves:

Manual product validation is time-consuming. This solution speeds up:
Market research
Competitor tracking
Sourcing suppliers
Launch planning

Social Love

// Detect dark theme var iframe = document.getElementById('tweet-1942117136442490900-631'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1942117136442490900&theme=dark" }
Made with ❤️ by Shreya N

Cloud Networking Showdown: AWS VPC vs. Azure VNET vs. Google Cloud VPC

Shreya Nalawade — Thu, 30 Jan 2025 13:54:14 +0000

Cloud computing has transformed how businesses operate, and at the heart of most cloud infrastructures are networking solutions. AWS VPC, Azure VNET, and Google Cloud VPC each offer ways to manage and connect virtual networks, but each has its own unique features and nuances. To make this comparison more relatable, let’s explore these cloud networking solutions through a simple analogy—think of them like different types of highways connecting cities (your servers and applications).

AWS VPC: The Established Highway System

AWS Virtual Private Cloud (VPC) is like a mature, well-maintained highway network—comprehensive, reliable, and familiar to many. AWS VPC gives you full control over your network environment, letting you create isolated virtual networks in the cloud, akin to building your own private highways.

Key features:

Customizable Network: You can design your VPC with subnets, route tables, and gateways to control how traffic flows.
Security: Features like security groups (firewalls for individual instances) and Network ACLs (access control lists for subnets) offer strong protections.
VPC Peering and Transit Gateway: You can connect multiple VPCs (think of them as different cities) using peering or Transit Gateways for broader network integration.

AWS has a robust ecosystem, with a wide variety of additional networking tools and services, such as Direct Connect (dedicated network links) and PrivateLink (secure access to services), making it a great option for organizations that require flexibility and scalability.

Azure VNET: The Highway with Easy On-Ramps

Azure’s Virtual Network (VNET) is like a highway system with smooth on-ramps and off-ramps that make it incredibly easy for developers to plug into. If you’re already in the Microsoft ecosystem, Azure VNET is designed with integrations in mind, making it simple to extend your existing Active Directory or hybrid workloads.

Key features:

Ease of Use: Azure VNET has built-in integration with many Microsoft tools, making it a seamless option for enterprises using Windows Server, Active Directory, or SQL Server.
Subnets and Network Security Groups: Just like AWS VPC, Azure VNET lets you segment your network into subnets. Network Security Groups (NSGs) are like custom rules that control traffic flow, providing a firewall-like protection.
Hybrid Connectivity: Azure provides strong hybrid connectivity options, including Azure ExpressRoute (similar to AWS Direct Connect) for establishing private connections between on-premises and the cloud.

While it might not be as feature-packed as AWS VPC, Azure VNET’s tight integration with other Microsoft services makes it ideal for businesses already working with Microsoft technologies.

Google Cloud VPC: The Smart, Adaptive Network

Google Cloud VPC is like a modern, smart highway system that adapts and grows based on the city’s needs. It’s optimized for simplicity, innovation, and low-latency services, leveraging Google’s expertise in networking and data management.

Key features:

Global Network: One of Google Cloud’s standout features is its global VPC. Unlike AWS or Azure, Google VPC allows you to create a single VPC across regions without needing to set up complex inter-region peering. It’s as if you could have a highway that seamlessly connects cities worldwide.
Simple and Flexible: Google VPC’s user interface is intuitive, making it easy to set up and manage. The VPC supports both private and public IPs, and firewall rules can be set at the global level, simplifying configuration.
Private Google Services Access: With Private Google Access, you can access Google Cloud services (like Cloud Storage and BigQuery) from within your VPC without needing to use the public internet.

Google Cloud VPC may not have the same depth of services as AWS or Azure, but it’s perfect for developers and businesses looking for a simple, highly scalable, and globally connected networking solution.

How They Compare: Highway Systems

Feature	AWS VPC	Azure VNET	Google Cloud VPC
Ease of Use	Feature-rich but complex	Simple with Microsoft integrations	Highly intuitive, simple setup
Global Connectivity	Limited to region-based VPCs	Region-based, with VPN support	Global VPC, no need for complex peering
Security	Granular control with SGs, ACLs	NSGs and firewall rules	Global firewall rules, customizable access
Hybrid Cloud Support	Direct Connect and VPN	ExpressRoute and VPN	Cloud Interconnect and VPN
Integration	Strong ecosystem, many tools	Best for Microsoft-heavy environments	Seamless integration with Google services

Conclusion: Which Highway is Right for You?

Choosing between AWS VPC, Azure VNET, and Google Cloud VPC boils down to your specific needs:

AWS VPC is ideal if you need a comprehensive, highly customizable, and scalable network, especially if you're dealing with complex applications or large enterprises.
Azure VNET is a solid choice for businesses heavily invested in Microsoft technologies, as it integrates seamlessly with on-premises solutions and Microsoft cloud tools.
Google Cloud VPC stands out if you need a global, simple, and high-performance network with ease of use and tight integration with Google Cloud services, especially for big data or machine learning workloads.

Just like choosing the right highway depends on where you need to go, selecting the right cloud provider’s networking solution depends on your company’s goals, existing infrastructure, and long-term strategy.

DBaaS Unleashed: Exploring DyanamoDB & RDS in the AWS

Shreya Nalawade — Tue, 31 Dec 2024 18:29:27 +0000

Database As A Service:
Database as a service (DBaaS) is a cloud computing managed service offering that provides access to a database without requiring the setup of physical hardware, the installation of software, or the need to configure the database. Most maintenance and administrative tasks are handled by the service provider, freeing up users to quickly benefit from using the database. DBaaS uses The DBaaS model is ideal for small to medium-sized businesses that do not have well-staffed IT departments. Offloading the service and maintenance of the database to the DBaaS provider enables small to medium-sized businesses to implement applications and systems that they otherwise could not afford to build and support on-premises. Workloads involving data with stringent regulatory requirements may not be suitable for a DBaaS model. Furthermore, mission-critical applications that require optimal performance and 99.999% of uptime may be better suited for on-premises implementation. This is not to say that mission-critical workloads cannot run on cloud services, but much of the DBaaS adoption to date has been for less crucial applications, such as development and pilot programs.

Detailed Implementation Steps: DynamoDB

Step 1: Select Database in AWS Services

Log in to the AWS Management Console.
Navigate to Services in the top menu.
Under the Database category, select DynamoDB.
- DynamoDB is a fully managed NoSQL database service designed for high availability and scalability.

Step 2: Go to DynamoDB Dashboard

Once inside DynamoDB, you'll see the dashboard where you can manage tables, monitor usage, and configure settings.
Familiarize yourself with the key sections, such as Tables, Metrics, and Global Tables, for future use.

Step 3: Create a Table

Click "Create Table" to open the table creation wizard.
Provide a Table Name (e.g., MyFirstTable). This must be unique within your AWS account.
Define the Primary Key:
- Partition Key: The unique identifier for each item (e.g., UserID).
- Sort Key (Optional): Used to sort items with the same Partition Key (e.g., OrderDate).
Configure additional settings (optional):
- Provisioned Throughput: Choose between "On-Demand" or "Provisioned" based on expected traffic.
- Encryption: Enable encryption at rest for enhanced security.
- Global Secondary Indexes (GSIs) or Local Secondary Indexes (LSIs) can be added for optimized querying.
Click "Create Table" to initiate table creation. It may take a few moments for the table to be ready.

Step 4: Confirm Table Creation

Once the table is created, it will appear in the Tables list.
Click on the table name to view its details, including schema, items, metrics, and indexes.

Step 5: Add Items to the Table

Navigate to the Items tab within your table.
Under Actions, click Create Item.

Step 6: Enter Item Data

The Create Item interface will open.
Enter values for the Partition Key and Sort Key (if applicable).
- Example: UserID = "12345", OrderDate = "2024-01-01".
Add additional attributes as key-value pairs, such as:
- Name = "John Doe"
- Email = "john.doe@example.com"
- OrderAmount = 150.25
Once all required attributes are added, click Save.

Step 7: View and Explore Items

Go back to the Items tab.
You’ll see a list of all items in the table.

Step 8: Query and Filter Data

In the Explore Items section, use the Scan operation to retrieve all items in the table.
Apply filters to refine your results:
- Example: Filter items where OrderAmount > 100.
Use the Query operation for more precise lookups, especially if your table has a Sort Key.

Step 9: Monitor Table Metrics

Go to the Metrics tab to view performance data, such as read/write capacity usage, throttling events, and storage utilization.
Adjust provisioned throughput if necessary to optimize performance.

Step 10: Delete the Table

Navigate to the DynamoDB dashboard and select the table you created.
Under Actions, choose Delete Table.
Confirm the deletion in the pop-up dialog.
- Note: Deleting a table is irreversible and removes all associated data.

Detailed Implementation Steps: RDS

Step 11: Navigate to AWS RDS

Log in to your AWS Management Console.
Click on Services in the top menu bar.
Under the Database section, select RDS.
- RDS (Relational Database Service) is a fully managed service that allows you to easily set up, operate, and scale a relational database in the cloud. It supports multiple database engines, including MySQL, PostgreSQL, Oracle, SQL Server, and Amazon Aurora.

Step 12: Create a Database in RDS

Once inside the RDS dashboard, click on "Databases" in the left navigation panel.
Click on the "Create database" button to start the database creation process.

Step 13: Configure Database Settings

Select the Database Engine: Choose the database engine you wish to use (e.g., MySQL, PostgreSQL, MariaDB, etc.).
- Example: Select MySQL for a relational database setup.

Choose a Template: You can choose between:
- Production: For highly available and scalable environments.
- Dev/Test: For lower cost, non-production environments.
- Free Tier: If you're eligible, this option provides limited free usage (1 GB of storage, 20 GB backup).

Settings:
- DB Instance Identifier: Choose a unique name for the instance (e.g., mydatabaseinstance).
- Master Username: Choose a username for the database administrator (e.g., admin).
- Master Password: Enter a strong password and confirm it.

DB Instance Class: Select the instance size (e.g., db.t3.micro for smaller, cost-effective setups or larger instance sizes for production workloads).
Storage:
- Storage Type: Choose between General Purpose (SSD) or Provisioned IOPS (SSD) for higher performance.
- Allocated Storage: Set the size for your database storage (e.g., 20 GB).
VPC and Network Configuration: Choose the VPC (Virtual Private Cloud) in which the RDS instance will run.
- Ensure you select the correct subnet group and security group. This will define the network and access permissions for the database.
Backup and Maintenance:
- Set the Backup Retention Period (how long backups are kept).
- Configure Automated Backups, Multi-AZ Deployment, and Maintenance window if needed.
Click on Create Database to start the database creation process.
- Note: The process may take a few minutes to complete.

Step 14: Access the Database Instance

After the database instance is created, click on the Database name (e.g., mydatabaseinstance) in the Databases tab to view its details.
You can see important information such as:
- Endpoint: The address you will use to connect to the database.
- VPC Security Group: The security group that controls access.
- DB Parameter Group: Configuration settings that define behavior of the database.
From this page, you can monitor performance, set up additional options, and access the database instance’s logs.

Step 15: Delete the Database Instance

To delete the database instance, go to the Databases page in the RDS dashboard.
Select the database instance you want to delete (e.g., mydatabaseinstance).
From the Actions dropdown menu, select Delete.
- A confirmation window will appear asking if you’re sure about deleting the instance.
You will be prompted to:
- Create a final snapshot (optional). You can choose to create a snapshot before deletion if you wish to back up the database’s current state.
- Retain automated backups: You can also choose whether to keep automated backups after deletion.
Click Delete to start the deletion process.
- The deletion of the instance may take some time, depending on the instance size and configuration.

Final Notes:

VPC Settings: Be cautious about the VPC (Virtual Private Cloud) settings as this dictates which resources can access your RDS instance. If your VPC is misconfigured, it may block the connection to your database.
Backups: Before deleting any instance, ensure that you have backed up any important data, as deleting the database is irreversible if you don’t retain backups.
Monitoring: After creation, use the CloudWatch monitoring tool to keep track of database performance (CPU usage, memory consumption, etc.).

Forem: Shreya Nalawade

Running Gemma 4 Inside a Docker Container with GPU Passthrough

Why Docker + GPU Is Annoying (and How It Actually Works)

Prerequisites Checklist

The Setup We're Building

Project Structure

Step 1: The .env File

Step 2: The Dockerfile

Step 3: The Model Pull Script

Step 4: LiteLLM Config

Step 5: The docker-compose.yml

Step 6: Boot It Up

Step 7: Test the OpenAI-Compatible Endpoint

Step 8: Drop It Into Your Existing Code

Python (openai SDK)

Node.js / TypeScript

LangChain

Step 9: The Smoke Test

Useful Day-to-Day Commands

Hardware Decision Guide

Common Errors and Fixes

What This Unlocks for Your Team

References

How Gemma 4's Per-Layer Embeddings Actually Work — And Why E2B Punches Above 2B

How Gemma 4's Per-Layer Embeddings Actually Work — And Why E2B Punches Above 2B

The Problem PLE Was Built to Solve

What Per-Layer Embeddings Actually Do

A Personal Example: The Word "Fine"

The Numbers: What This Actually Unlocks

How E2B Compares to Other Small Models

vs. Phi-4 Mini / Phi-3 Mini (Microsoft)

vs. Qwen 3.5 0.8B / 1.8B (Alibaba)

vs. Llama 3.2 3B (Meta)

vs. Gemma 3 2B (previous generation)

What PLE Means for Quantization

The parameter split matters

Practical RAM targets (approximate, Q4 build)

Implication for fine-tuning

The Bigger Picture: What "Effective Parameters" Really Means

Summary: The Mechanism

References and Further Reading

Zero Waste, Zero Stress: Building ReMake with AI-Assisted Github Copilot Development

🎯 Introduction

🚀 What is Second Life ReMake?

🤝 How GitHub Copilot Helped Build This App

1. Copilot Chat: My Instant Stack Overflow

Example: Implementing Image Upload with Preview

2. Copilot Agent: The Autonomous Code Generator

Example: Building the Material Analysis API Integration

3. Copilot Inline Suggestions: The Silent Productivity Booster

Example: Generating Upcycling Projects

📊 Development Velocity: Before vs. After Copilot

🎨 The Full Tech Stack

📝 Key Features Built with Copilot's Help

1. Smart Image Upload System

2. AI Material Analysis Engine

3. Dynamic Project Generator

4. Progress Dashboard

5. Community Marketplace

🧠 Lessons Learned: Maximizing Copilot's Potential

✅ DO:

🌍 Real-World Impact

📦 Try It Yourself

📦 PRIZE CATEGORIES - BEST USE OF GITHUB COPILOT

🤝 Join the Movement

Build a Website Using S3 and CloudFront with Terraform

Introduction

Key Requirements

Choosing the Hosting Platform

Architecture Diagram

Why Terraform?

Terraform Template Example

Understanding CloudFront

Built-in Security Features

Understanding Amazon S3

Why S3 + CloudFront?

Benefits

Step-by-Step Implementation

Step 1: Install Terraform

Conclusion

Step 1: The `.env` File