If you’ve ever assigned Billing permissions to an AWS SSO (IAM Identity Center) user and still hit AccessDenied errors in Cost Explorer, you’re not alone. This post documents a real-world debugging journey and the actual root cause — including recent AWS UI changes that make this even more confusing.

The Symptom

After logging in via IAM Identity Center (SSO), the user sees errors like:

• You don’t have permission to perform ce:DescribeReport
• IAM user access not activated
• Billing console opens, but Cost Explorer fails

This happens even when:

• The user has Billing permission set
• Additional cost-related policies are attached
• The user is in the management (payer) account

First Key Understanding: SSO Users ≠ IAM Users

• IAM Identity Center users do not appear under IAM → Users
• Billing access is not inherited automatically
• All billing access is enforced at the account level, not service level

So simply assigning permissions is never enough.

The Permission Layer (What Most People Check)

Correct permission set choices

• ✅ Billing
• ✅ AWSBillingReadOnlyAccess (recommended)
• ❌ ReadOnlyAccess
• ❌ ViewOnlyAccess
• ❌ PowerUserAccess

Important: Billing ≠ Cost Explorer Cost Explorer requires explicit ce:* permissions.

The misleading policies

Searching for “cost” shows policies like:

• AWSCostAndUsageReportAutomationPolicy
• CostOptimizationHubAdminAccess
• CostOptimizationHubReadOnlyAccess

None of these grant Cost Explorer access.

The Real Root Cause (What Actually Breaks Everything)

❌ IAM / SSO access to Billing was NOT activated

This is a Root-only, account-level gate.

Even with:

• AdminAccess
• Billing permission set
• Correct account

Billing APIs (aws-portal:*, ce:*) are hard blocked until this is enabled.

The Fix (The One That Finally Works)

Login as Root user (mandatory)

Then:

1. Go to Billing & Cost Management
2. Open Account / Billing preferences
3. Enable:

✅ IAM user and role access to Billing information (“Activate IAM Access”)

⚠️ Notes:

• There is no Save button
• The change applies immediately
• IAM / SSO users cannot enable this — only Root

After Enabling (Critical Step)

• Fully log out
• Log back in via SSO
• Open Cost Explorer

✅ Access works instantly

Why AWS Designed It This Way

AWS enforces three separate security gates for billing:

1. Root-only account-level activation
2. IAM / SSO permission set
3. Correct account context (management/payer)

This prevents:

• Accidental exposure of financial data
• Privilege escalation via Admin roles
• Cross-account cost leakage in Organizations

Common Traps (Checklist)

• ❌ Billing permission set without Root activation
• ❌ Assuming AdminAccess includes billing
• ❌ Attaching “cost”-named policies that don’t include ce:*
• ❌ Logging into a member account instead of payer
• ❌ Not re-logging after permission sync

Final Working Setup (Reference)

• Root enabled IAM user and role access to Billing

• Permission set includes:

  • Billing
  • AWSBillingReadOnlyAccess (or custom ce:Get*)
• Assigned to management account
• User logs in via IAM Identity Center

TL;DR (Interview-Ready Summary)

• Billing access in AWS is account-gated, not role-gated
• Permission sets are ignored until Root flips the switch
• Cost Explorer requires explicit ce:* permissions
• Most billing issues fail at the account-level control, not IAM

If this saved you time, consider turning it into a reusable Cost-Only permission set for your org — it prevents accidental payment access while keeping engineers informed.

Happy cloud debugging ☁️

But manually scheduling 5 review sessions every time you learn something new is a chore. So, I built a tool that does it for you.

In this guide, I’ll show you how to turn a simple Google Sheet into a powerful automation hub that schedules review sessions in your Google Calendar and emails you a study plan automatically.

🛠️ The Workflow

1. Type a Topic into your Google Sheet.
2. The script calculates intervals for 1, 3, 7, 21, and 45 days.
3. Five Calendar events are created at 9:00 AM on those dates.
4. You receive a summary email with your complete study plan.

🚀 Step 1: Prepare the Google Sheet

1. Create a new Google Sheet.
2. Label Cell A1 as Topic and Cell B1 as Status.
3. Give your sheet a name (e.g., "My Study Tracker").

💻 Step 2: Adding the Code

1. Go to Extensions > Apps Script.
2. Delete any code in the editor and paste the following script:

/**
 * THE MAIN TRIGGER FUNCTION
 * This will run automatically once the "Installable Trigger" is set up.
 */
function createSpacedRepetition(e) {
  const range = e.range;
  const sheet = range.getSheet();
  const column = range.getColumn();
  const row = range.getRow();
  const topic = e.value;
  const statusCell = sheet.getRange(row, 2);

  // Only run if in Column A, Row 2+, and cell is not empty
  if (column === 1 && row > 1 && topic) {

    // Check if already processed to avoid duplicates
    if (statusCell.getValue() === "✅ Events & Email Sent!") return;

    statusCell.setValue("⏳ Scheduling...");

    try {
      // 1. Calculate Intervals and Create Calendar Events
      const intervals = [1, 3, 7, 21, 45]; 
      let scheduleDetails = [];

      intervals.forEach((days, index) => {
        const sessionDate = new Date();
        sessionDate.setDate(sessionDate.getDate() + days);
        sessionDate.setHours(9, 0, 0, 0); // Scheduled for 9 AM

        const title = `Review ${index + 1}: ${topic}`;
        const endTime = new Date(sessionDate.getTime() + (30 * 60 * 1000)); // 30 min duration

        const calendar = CalendarApp.getDefaultCalendar();
        calendar.createEvent(title, sessionDate, endTime, {
          description: "Spaced Repetition Session for " + topic
        });

        scheduleDetails.push({ step: index + 1, date: sessionDate.toDateString() });
      });

      // 2. Send the Summary Email
      sendSummaryEmail(topic, scheduleDetails);

      // 3. Update Sheet
      statusCell.setValue("✅ Events & Email Sent!");

    } catch (err) {
      statusCell.setValue("❌ Error: " + err.toString());
    }
  }
}

/**
 * Helper function to send a formatted email
 */
function sendSummaryEmail(topic, schedule) {
  const myEmail = Session.getEffectiveUser().getEmail();
  const subject = "📚 New Study Plan: " + topic;

  const htmlBody = `
    <div style="font-family: sans-serif;">
      <h3>Plan for: ${topic}</h3>
      <p>I've added 5 sessions to your calendar:</p>
      <ul>
        ${schedule.map(s => `<li><b>Session ${s.step}:</b> ${s.date}</li>`).join("")}
      </ul>
      <p>Happy learning!</p>
    </div>
  `;

  GmailApp.sendEmail(myEmail, subject, "", { htmlBody: htmlBody });
}

⚙️ Step 3: The "Secret Sauce" (Installable Triggers)

This is the most important part. A normal script isn't allowed to touch your Calendar or Email for security reasons. We have to "install" the trigger manually to give it permission.

1. In the Apps Script sidebar, click the Alarm Clock icon (Triggers).
2. Click + Add Trigger (bottom right).
3. Select createSpacedRepetition as the function to run.
4. Set the event source to From spreadsheet.
5. Set the event type to On edit.
6. Click Save and accept the permissions popup (click Advanced and Allow).

🎯 The Result

Now, whenever you finish a tutorial or read a great technical article, just type the name into your spreadsheet.

Within seconds, your calendar will look like a roadmap to mastery, and you'll have an email waiting for you with the details. This system ensures you're reviewing concepts right when your brain is about to forget them.

If you’ve ever heard terms like data lake, data warehouse, ETL, streaming, or lakehouse and thought:

“I kind of get it… but not really”

—you’re not alone.

This post breaks down modern data architecture in simple terms, explains why each component exists, and shows how data flows from raw events to dashboards and machine learning.

No buzzwords. No vendor hype. Just clarity.

The Big Picture: What Are We Even Building?

At a high level, a data platform does one thing:

Turns raw data into useful decisions

That’s it.

Everything else exists to support this journey:

Raw data → Clean data → Insights → Decisions

Step 1: Data Ingestion – “How Data Enters the System”

Ingestion simply means bringing data in.

Where does data come from?

• App clicks

• Payments

• Logs

• IoT sensors

• Third-party APIs

• Databases

Two common ingestion styles

1. Batch ingestion

Think of this like:

“Upload yesterday’s data once a day”

• Slower

• Cheaper

• Great for reports

2. Real-time (Streaming) ingestion

Think of:

“Data arrives the moment it happens”

• Faster

• Used for alerts, monitoring, live dashboards

📌 Key idea: Ingestion tools don’t analyze data — they move it safely and reliably.

Step 2: Storage – “Where Data Lives”

Once data arrives, it needs a home.

Data Lake – The Raw Storage Room

A data lake stores data as-is.

• Structured (tables)

• Semi-structured (JSON)

• Unstructured (logs, images)

Think:

“Dump everything here first. We’ll figure it out later.”

✅ Cheap ❌ Messy if unmanaged

Data Warehouse – The Organized Library

A data warehouse stores clean, structured, ready-to-query data.

Think:

“Only curated, trusted data allowed.”

• Fast analytics

• Used by analysts & business teams

• Powers dashboards

✅ Fast & reliable ❌ Less flexible

Lakehouse – Best of Both Worlds

A lakehouse combines:

• The flexibility of a data lake

• The performance of a warehouse

Think:

“One system instead of two.”

This is why lakehouses became popular — less duplication, fewer pipelines.

Step 3: Data Transformation – “Making Data Useful”

Raw data is messy.

Transformation is where we:

• Clean data

• Join datasets

• Apply business logic

• Create metrics

This is often called ETL or ELT.

ETL vs ELT (don’t panic)

• ETL: Transform before storing

• ELT: Store first, transform later

Modern systems mostly use ELT.

📌 Key idea: Transformation turns data into information.

Step 4: Orchestration – “Who Runs What, and When?”

Imagine running 50 data jobs manually every day.

That’s where orchestration comes in.

Orchestration tools:

• Schedule workflows

• Handle dependencies

• Retry failures

• Send alerts

Think:

“The conductor of the data orchestra”

Without orchestration:

• Pipelines break silently

• Data becomes unreliable

Step 5: Governance – “Trust, Security, and Control”

As data grows, questions arise:

• Who can access what?

• Is this data accurate?

• Where did it come from?

Governance solves this.

It includes:

• Access control

• Data catalogs

• Lineage (where data came from)

• Compliance

Think:

“Rules, labels, and locks for your data”

📌 Good governance = trusted data

Step 6: BI & Visualization – “Turning Data into Answers”

This is the part everyone recognizes.

Dashboards show:

• Revenue

• Growth

• User behavior

• Performance trends

BI tools let non-technical users:

• Explore data

• Ask questions

• Make decisions

📌 If leadership can’t understand it, the system failed.

Step 7: Machine Learning – “From Insight to Prediction”

Once data is clean and reliable, it can power:

• Recommendations

• Forecasts

• Fraud detection

• Personalization

ML systems depend entirely on the earlier steps.

No clean data → no good models.

Putting It All Together (Simple Flow)

1. Ingestion – data comes in

2. Storage – data is stored (lake / warehouse / lakehouse)

3. Transformation – data is cleaned and shaped

4. Orchestration – workflows are managed

5. Governance – data is secured and trusted

6. BI & ML – data creates value

Every layer exists for a reason.

Why This Architecture Matters

Without this structure:

• Reports disagree

• Data breaks silently

• Teams lose trust

• Decisions become guesses

With it:

• Everyone works from the same truth

• Insights are faster

• Systems scale

• Data becomes an asset, not a liability

Final Thought

Modern data architecture isn’t about tools.

It’s about clarity, trust, and flow.

If you understand:

“Where data comes from, where it lives, how it changes, and who uses it”

—you understand 90% of data engineering.

This post is a complete, end-to-end guide to dbt, covering:

• What problems it solves

• Core concepts (models, materialization, lineage)

• Medallion architecture

• CI/CD with GitHub Actions

• Interview-ready mental models and scenarios

1. What is dbt?

dbt (data build tool) is a SQL-first transformation framework that runs transformations inside your data warehouse.

What dbt is for

• Transforming raw data into analytics-ready tables

• Applying software engineering practices to analytics

• Enabling testing, documentation, and lineage

What dbt is NOT for

• Data ingestion (Fivetran, NiFi, Glue)

• Orchestration (Airflow)

• Streaming or real-time processing

One-liner: dbt brings version control, testing, and CI/CD to SQL-based analytics.

2. The Problem dbt Solves

Before dbt:

• Business logic lives in BI tools

• No version control for SQL

• Broken dashboards after schema changes

• No visibility into downstream impact

With dbt:

• All transformations live in Git

• SQL is modular and testable

• Automatic dependency graph (lineage)

• Safe deployments via CI/CD

3. Core dbt Concepts (You Must Know)

3.1 Models

• SQL SELECT statements

• Each model becomes a table, view, or incremental table

• Dependencies defined using ref()

select *
from {{ ref('stg_orders') }}

3.2 Materialization (Very Important)

Materialization defines how a model is stored in the warehouse.

Example (incremental):

{{ config(materialized='incremental', unique_key='order_id') }}

select *
from raw.orders
{% if is_incremental() %}
where updated_at > (select max(updated_at) from {{ this }})
{% endif %}

Materialization is dbt’s cost and performance control knob.

3.3 Sources

• Explicit declaration of raw tables

• Enables freshness and source tests

sources:
  - name: raw
    tables:
      - name: orders

3.4 Tests

• Built-in tests:

  • not_null

  • unique

  • relationships

• Custom SQL tests supported

Tests fail the pipeline, not silently.

3.5 Macros

• Reusable SQL using Jinja

• Helps avoid duplication

• Used for:

  • Date logic

  • Environment-based behavior

  • Custom tests

3.6 Snapshots

• Track historical changes (SCD Type 2)

• Useful when source systems don’t provide history

4. Data Lineage Explained Simply

Lineage = visual map of data flow from source to final model.

dbt builds lineage automatically using:

• source()

• ref()

Example:

raw.orders
   ↓
stg_orders
   ↓
int_orders
   ↓
fct_orders

Why lineage matters

• Impact analysis

• Faster debugging

• Safer CI/CD

• Easier onboarding

dbt lineage shows data dependencies, not execution order.

5. Medallion Architecture (Bronze → Silver → Gold)

Bronze (Raw)

• Ingested data

• Minimal transformation

• Append-only

Silver (Cleaned)

• Deduplication

• Type casting

• Business logic begins

Gold (Analytics)

• Aggregated

• Business-ready

• Used by BI tools

How dbt fits

• Bronze → dbt sources

• Silver → staging models

• Gold → marts

6. dbt in the Modern Data Stack

dbt focuses on the last mile of analytics.

7. CI/CD for dbt (Production-Grade)

Why CI/CD is critical

• Prevent broken SQL in prod

• Catch schema changes early

• Enforce data quality

CI (Pull Requests)

• dbt compile

• Slim CI (state:modified+)

• Run tests on changed models only

CD (Main branch)

• Full dbt run

• Full dbt test

• Generate documentation

8. GitHub Actions – Complete CI/CD Workflow

Environments

• dev → CI

• prod → production deploy

CI + CD Workflow

name: dbt-ci-cd

on:
  pull_request:
  push:
    branches: [main]

jobs:
  dbt-ci:
    runs-on: ubuntu-latest
    environment: dev
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: '3.10'
      - run: pip install dbt-snowflake
      - run: dbt deps
      - run: dbt compile
      - run: dbt test

  dbt-prod:
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    environment: prod
    needs: dbt-ci
    steps:
      - uses: actions/checkout@v4
      - run: pip install dbt-snowflake
      - run: dbt run
      - run: dbt test

9. Real Interview Scenarios

Why dbt over stored procedures?

• Version control

• Testing

• Lineage

• CI/CD

• Modular SQL

How do you handle large tables?

• Incremental models

• Partitioning

• Late-arriving data logic

How do you stop bad data in prod?

• CI tests

• Protected branches

• Mandatory PR checks

10. Final Mental Model

• dbt → Transform data

• Materialization → Control cost & performance

• Lineage → Trust & impact analysis

• Medallion architecture → Structure data layers

• CI/CD → Safe, scalable deployments

Final One-Liner

dbt is a SQL-based analytics engineering framework that enables trusted, testable, and production-ready data transformations using modern software engineering practices.

• Nginx (frontend)
• Redis (backend)
• With Bitnami Redis as a dependency
• Includes hooks, schema validation, and packaging
• And finally, pushing the packaged chart to Azure Container Registry (ACR)

Perfect for anyone learning Helm or preparing for DevOps interviews.

📌 What You Will Build

A fully working Kubernetes deployment using:

• A top-level Helm chart (nginx-redis-chart)
• A Redis subchart (Bitnami)
• Custom templates for Nginx Deployment + Service
• A pre-install hook job
• A JSON schema validator
• A packaged .tgz Helm artifact published to ACR

🧰 Prerequisites (Windows Setup)

• Install Helm:

  choco install kubernetes-helm
  

• Install Minikube:

  winget install Kubernetes.minikube
  

• Enable virtualization → install Docker Desktop

• Start Minikube:

  minikube start --driver=docker
  

• Verify:

  kubectl get nodes
  helm version
  

📁 Step 1 — Create the Helm Chart

helm create nginx-redis-chart
cd nginx-redis-chart

This generates:

Chart.yaml
values.yaml
templates/
charts/

📦 Step 2 — Add Redis Dependency

Add Bitnami Redis to Chart.yaml:

dependencies:
  - name: redis
    version: 19.0.0
    repository: "https://charts.bitnami.com/bitnami"

Update dependencies:

helm repo add bitnami https://charts.bitnami.com/bitnami
helm repo update
helm dependency update .

This pulls Redis into charts/redis-*.tgz.

⚙️ Step 3 — Configure values.yaml

replicaCount: 2

image:
  repository: nginx
  tag: stable
  pullPolicy: IfNotPresent

service:
  type: ClusterIP
  port: 80
  targetPort: 80

redis:
  enabled: true
  fullnameOverride: redis
  architecture: standalone
  usePassword: false

🧱 Step 4 — Create Nginx Deployment

templates/deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ include "nginx-redis-chart.fullname" . }}-nginx
  labels:
    app: {{ include "nginx-redis-chart.name" . }}
spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      app: {{ include "nginx-redis-chart.name" . }}
  template:
    metadata:
      labels:
        app: {{ include "nginx-redis-chart.name" . }}
    spec:
      containers:
        - name: nginx
          image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
          imagePullPolicy: {{ .Values.image.pullPolicy }}
          ports:
            - containerPort: {{ .Values.service.targetPort }}
          env:
            - name: REDIS_HOST
              value: {{ printf "%s-redis-master" (include "nginx-redis-chart.fullname" .) | quote }}

🌐 Step 5 — Create Nginx Service

templates/service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: {{ include "nginx-redis-chart.fullname" . }}-svc
spec:
  type: {{ .Values.service.type }}
  ports:
    - port: {{ .Values.service.port }}
      targetPort: {{ .Values.service.targetPort }}
  selector:
    app: {{ include "nginx-redis-chart.name" . }}

🪝 Step 6 — Pre-install Hook Job

templates/preinstall-job.yaml:

apiVersion: batch/v1
kind: Job
metadata:
  name: "{{ include "nginx-redis-chart.fullname" . }}-preinstall"
  annotations:
    "helm.sh/hook": pre-install
    "helm.sh/hook-delete-policy": before-hook-creation,hook-succeeded
spec:
  template:
    spec:
      restartPolicy: Never
      containers:
        - name: preinstall
          image: bitnami/kubectl:latest
          command: ["sh","-c","echo Pre-install hook executed"]

🧪 Step 7 — Add JSON Schema Validation

Create values.schema.json:

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "replicaCount": { "type": "integer", "minimum": 1 },
    "image": {
      "type": "object",
      "properties": {
        "repository": { "type": "string" },
        "tag": { "type": "string" }
      }
    },
    "service": {
      "type": "object",
      "properties": {
        "type": { "type": "string", "enum": ["ClusterIP","NodePort","LoadBalancer"] },
        "port": { "type": "integer" },
        "targetPort": { "type": "integer" }
      }
    },
    "redis": { "type": "object" }
  }
}

Validate:

helm lint .

🚀 Step 8 — Install the Chart

helm install my-nginx . -n test --create-namespace

Check resources:

kubectl get all -n test

You’ll see:

• Redis StatefulSet + Pod
• Nginx Deployment (2 pods)
• Services for Redis and Nginx

📦 Step 9 — Package the Chart

helm package .

Produces:

nginx-redis-chart-0.1.0.tgz

☁️ Step 10 — Push to Azure Container Registry (ACR)

1️⃣ Login to ACR

az login
az acr login --name <acr-name>

2️⃣ Push Helm chart to ACR

helm push nginx-redis-chart-0.1.0.tgz oci://<acr-name>.azurecr.io/helm

3️⃣ Verify

az acr repository list --name <acr-name> --output table

4️⃣ Install from ACR

helm install my-nginx oci://<acr-name>.azurecr.io/helm/nginx-redis-chart --version 0.1.0

🎉 Final Thoughts

You now have:

• A complete custom Helm chart
• Redis subchart integration
• A working Nginx + Redis deployment
• Schema validation
• Helm hooks
• Packaged chart
• Pushed to Azure Container Registry

This is a fully production-style Helm workflow, excellent for DevOps learning and interviews.

🔹 Step 1: Check Existing Java Installation

Open Command Prompt and run:

java -version
javac -version

Example output if Java 25 is installed:

java version "25" 2025-09-16 LTS
javac 25

⚠️ If you see mismatched versions or want to add Java 21, follow the next steps.

🔹 Step 2: Download Java 21 JDK

1. Go to the official Oracle JDK download page: Oracle Java Downloads

2. Download Java SE Development Kit 21 for Windows x64 (.exe installer).

🔹 Step 3: Install Java 21 Alongside Java 25

1. Run the installer.
2. Choose a separate installation path to avoid conflicts, e.g.:

C:\Program Files\Java\jdk-21

3. Complete the installation.

✅ You now have Java 25 and Java 21 installed on your system.

🔹 Step 4: Configure JAVA_HOME for Java 21

1. Press Win + S, search for Environment Variables, and open Edit the system environment variables → Environment Variables.

2. Under System variables, find JAVA_HOME → Edit:

   • Set the value to your Java 21 folder:

C:\Program Files\Java\jdk-21

3. Ensure your Path includes:

%JAVA_HOME%\bin

• Move it to the top of the PATH list to prioritize Java 21 over Java 25.

• Click OK to save.

🔹 Step 5: Verify Java 21 Installation

Open a new Command Prompt and run:

java -version
javac -version

Expected output:

java version "21.0.x" 2025-07-15 LTS
javac 21

🎉 Your system now uses Java 21, while Java 25 remains installed for other projects.

🔹 Step 6: Optional – Switching Between Java Versions

If you want to switch between Java 21 and Java 25:

Temporary Switch in a Terminal

set JAVA_HOME=C:\Program Files\Java\jdk-25
set PATH=%JAVA_HOME%\bin;%PATH%
java -version
javac -version

This affects only the current terminal session.

Permanent Switch

• Change JAVA_HOME and move %JAVA_HOME%\bin to the top of Path to switch system-wide.

🔹 Step 7: Download and Install Apache Maven

1. Go to Apache Maven Downloads and download the Binary zip archive of the latest version (e.g., 3.9.11).
2. Extract it to a folder, e.g.:

C:\Maven\apache-maven-3.9.11

3. Set environment variables:

   • M2_HOME → C:\Maven\apache-maven-3.9.11
   • Add %M2_HOME%\bin to Path.

4. Open a new Command Prompt and check:

mvn -version

Expected output:

Apache Maven 3.9.11
Java version: 21, vendor: Oracle Corporation
Java home: C:\Program Files\Java\jdk-21

🔹 Step 8: Optional – Test a Maven Project

Create a sample Maven project:

mvn archetype:generate -DgroupId=com.example -DartifactId=MyApp -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
cd MyApp
mvn compile
mvn exec:java -Dexec.mainClass="com.example.App"

This ensures your Maven and Java setup works end-to-end.

🔹 Summary Table

✅ Conclusion

You now have Java 21 installed alongside Java 25 and a working Maven environment on Windows.

This setup lets you switch between Java versions for different projects while keeping your system organized and conflict-free.

💡 Pro Tip: Use JAVA_HOME + PATH order or terminal set commands to switch Java versions quickly for different projects.

🔹 Step 1: Check Existing Java Installation

Before installing, check if Java is already installed:

java -version
javac -version

• If Java is installed, you’ll see something like:

java version "1.8.0_121"
javac 11.0.16.1

⚠️ If the versions don’t match (e.g., JRE is Java 8, but javac is Java 11), it’s recommended to update to the latest version.

🔹 Step 2: Download Java JDK

1. Go to the official Oracle JDK download page: Oracle Java Downloads

2. Find the latest Java SE Development Kit (JDK). Example: Java 25 LTS.

3. Under Windows, download the x64 Installer (.exe).

🔹 Step 3: Install Java JDK

1. Double-click the downloaded installer.

2. Follow the setup wizard:

   • Keep the default installation path (e.g., C:\Program Files\Java\jdk-25).
   • Click Next and Finish when installation completes.

🔹 Step 4: Set JAVA_HOME and Update PATH

1. Press Win + S → type Environment Variables → open Edit the system environment variables → click Environment Variables.

2. Create JAVA_HOME

   • Click New under System variables.
   • Variable name: JAVA_HOME
   • Variable value: C:\Program Files\Java\jdk-25

3. Add to PATH

   • Select Path → Edit → New → %JAVA_HOME%\bin
   • Move it to the top to take priority.

4. Click OK to save.

🔹 Step 5: Verify Java Installation

Open a new Command Prompt and type:

echo %JAVA_HOME%
java -version
javac -version

Expected output:

C:\Program Files\Java\jdk-25
java version "25" 2025-09-16 LTS
javac 25

✅ This confirms Java is correctly installed and configured.

🔹 Step 6: Download Apache Maven

1. Go to the official Apache Maven download page: Apache Maven Downloads

2. Download the Binary zip archive of the latest version. Example: apache-maven-3.9.11-bin.zip

3. Extract it to a folder, for example:

C:\Maven\apache-maven-3.9.11

🔹 Step 7: Set M2_HOME and Add Maven to PATH

1. Open Environment Variables again.

2. Create M2_HOME

   • Click New under System variables.
   • Variable name: M2_HOME
   • Variable value: C:\Maven\apache-maven-3.9.11

3. Add Maven to PATH

   • Select Path → Edit → New → %M2_HOME%\bin
   • Move it to the top.

4. Click OK to save.

🔹 Step 8: Verify Maven Installation

Open a new Command Prompt and run:

mvn -version

Expected output:

Apache Maven 3.9.11 (xxxx)
Maven home: C:\Maven\apache-maven-3.9.11
Java version: 25, vendor: Oracle Corporation
Java home: C:\Program Files\Java\jdk-25

✅ Maven is installed and correctly using your Java setup.

🔹 Summary Table of Installed Versions

✅ Conclusion

You now have Java JDK 25 and Apache Maven 3.9.11 installed and fully configured on Windows.

Your system is ready for Java development, building projects, and running Maven-based applications.

💡 Tips:

• Always use the latest LTS version of Java for production projects.
• Keep JAVA_HOME and M2_HOME updated when upgrading.
• Using Maven with Java 25 ensures compatibility with modern libraries and frameworks.

🗂️ Data & Compute Frameworks

• cuDF vs Pandas → cuDF accelerates DataFrames on GPUs; offers 10–100x speedups over CPU-based Pandas.
• QML (Quantum ML) → NVIDIA is bringing scikit-learn–like usability to quantum-inspired ML workflows.

🏗️ Application Blueprints

• CI/CD Pipeline Blueprint → NVIDIA provides production-ready YAML-based blueprints for deploying AI into enterprise pipelines.
• Multimodal PDF Processing → Prebuilt blueprint for parsing, understanding, and reasoning over PDFs with LLMs.
• In-Vehicle Frameworks → ADAS/AV development supported by BEVFormer (Bird’s Eye View transformer models).

🧬 Bio & Pharma AI

• BioNeMo → NVIDIA’s framework for protein structure modeling, drug discovery.
• AlphaFold / AlphaFold2 integrated for structure prediction.
• Case studies showed pharma discovery workflows accelerated by GPUs.

☁️ Cloud & Infrastructure

• NeMo Everywhere → Works on cloud (AWS, Azure, GCP, Yotta) and on-prem (MCP).
• Consistency → NeMo behaves the same across environments.
• MCP (Multi-Cloud Platform) → Production-grade stack with observability, profiling, parallel agent execution.
• Vendor Neutral → NVIDIA claims its tools integrate across ecosystems, not locked-in.
• India AI Mission → Local sovereign cloud providers like Yotta are onboard.
• Zoho AI → Deploying workloads on Yotta Cloud.

🧑‍🤝‍🧑 Agents & Agentic AI

• AI Agents → Autonomous but human-in-the-loop.
  • Example: Book tickets → Planner Agent with reasoning + actions.
• Types:
  • React Agent → “Reason + Act” agent.
  • Resolver Agent → Gathers multiple agents’ opinions, finds best option.
  • Project Manager Agent → Manages tasks, meetings, CRM, transcripts.
• Tools:
  • NeMo Agent Toolkit vs LangGraph → NVIDIA offers production-ready, YAML-driven approach.
  • Profiling & Observability → Unique to NeMo Agents; enables debugging & bottleneck detection.
  • Parallelization → Converts serial LLM calls into parallel agent execution.
  • A2A (Agent-to-Agent) → Agents communicate directly (like Google, Anthropic).

🔍 AI Query Engine

• Agents can serve as query engines.
• Uses tries and different reasoning modes for flexible answering.

🛡️ Security & Analysis

• CVE Analysis Agent (Morpheus) → Automates vulnerability scans with AI.
• Test-Driven Development for Agents → Issue understanding → Code embedding → Code generation → Reflection loop.

💼 Enterprise Ecosystem

• SAP & ServiceNow → NVIDIA tools integrate rather than reinvent.
• Observability + Ease of Integration → Focus on making agents enterprise-ready.
• NVIDIA Inception Program → Startups get 5+ years eligibility, support, GPUs, SDK access.

⚡ Hardware

• Blackwell GPUs → Improved energy efficiency & power consumption.

📓 Hands-On Labs

• Shared Jupyter Notebook (nemo_agent_code_generation.ipynb) for building agents, profiling, and code generation workflows.

🎤 Case Studies

• Caceis → Used Project Manager Agent for client meetings.
• Pharma Discovery → BioNeMo + AlphaFold accelerates drug development.

✨ Key Takeaways

• NVIDIA is pushing agentic AI as the future of enterprise automation.
• NeMo Agents stand out with production readiness, observability, YAML-based customization, and parallel execution.
• Strong ecosystem integration: SAP, ServiceNow, Zoho, Yotta (India AI Mission).
• Hardware + software synergy (Blackwell GPUs, MCP, NeMo, Morpheus).
• Pharma, automotive, enterprise, and cloud all converging on agent-first workflows.