This is a submission for Weekend Challenge: Earth Day Edition

What Inspired Me

Last month I scrolled past three climate headlines before breakfast. Record heat. Melting ice. Endangered species. Each one felt like a notification from a planet I'd muted.

The problem isn't data — we have more climate data than ever. The problem is that data doesn't talk to you. It shows you a chart, you nod, you scroll on. What if the data knew you? What if it said "you specifically could cut 1.5 tonnes by switching your electricity provider" instead of "global temperatures rose 0.1°C"?

That question became Planetary Pulse: not another doom dashboard, but a planetary health companion that sees the big picture, knows your habits, and tells you exactly what to do about it.

I also wanted to prove something: that you can integrate six different technologies in a weekend without it feeling like a Frankenstein app. Each tech solves a real problem — not a checkbox.

What I Built

Planetary Pulse is a full-stack environmental dashboard with four interactive tabs, seven climate datasets, an AI assistant that remembers you, a carbon calculator, and a blockchain-verified carbon credit marketplace.

The main dashboard: health score ring, 7 environmental metrics, animated globe, trend chart, and AI-powered insights panel

Key features:

• 📊 Real-time dashboard with 7 environmental metrics from NASA, NOAA, NSIDC, IRENA, WWF via Snowflake
• 🤖 AI climate assistant with Backboard persistent memory that learns your habits across sessions
• 🧠 Gemini-powered analysis — structured JSON insights, not generic chatbot responses
• 🔐 Auth0-secured user accounts with scoped AI agent tokens
• 🪙 Solana-tracked carbon credit marketplace with on-chain retirement
• 🧮 IPCC-based calculator for personal carbon footprint with 8 transport modes and 5 diet types

Demo

🌍 Live Demo: https://planetary-pulse-fgdk.onrender.com

Works with zero API keys — all integrations have realistic mock fallbacks. Add keys to unlock live data.

The Four Tabs

AI Assistant: Backboard-powered persistent memory remembers your EV, your diet, your solar panel interest across sessions

Personal Carbon Calculator: IPCC AR6 calibrated, compares you against global average and 1.5°C target

Carbon Credit Marketplace: browse verified projects, retire on Solana, track cumulative impact

Code

📂 Source Code: https://github.com/mamoor123/Planetary-Pulse

   NASA, NOAA, WWF
        │
        ▼
  ┌─────────────┐
  │  ❄️ SNOWFLAKE │ ◀── 7 climate datasets
  │  Data Lake   │     1880 → 2024
  └──────┬──────┘
         │
         ▼
  ┌─────────────┐
  │  ✨ GEMINI   │ ◀── AI interprets the numbers
  │  Analysis    │     "What does this mean for ME?"
  └──────┬──────┘

git clone https://github.com/mamoor123/Planetary-Pulse.git
cd Planetary-Pulse
npm install
cp .env.example .env  # Optional
npm start
# Open http://localhost:3000

How I Built It

The Architecture That Makes It Work Offline

The biggest engineering decision: every integration falls back to mock data automatically. The app tries the real API, catches any failure, and serves cached datasets with real climate values. This means:

• Judges can evaluate without API keys ✅
• The demo never breaks ✅
• You can develop without hitting rate limits ✅
• Each route file is self-contained: server/routes/backboard.js, gemini.js, snowflake.js, solana.js, carbon.js

The frontend is vanilla HTML/CSS/JS — no React, no build step. One index.html + app.js + style.css. The dark theme, animated CSS globe, SVG health ring, and tab system are all hand-coded. I chose this deliberately: you don't need a framework to ship something polished.

🟣 Backboard — The AI That Actually Remembers You

This is what makes the assistant feel alive. Most AI chatbots start from zero every session. Backboard gives it persistent memory — it automatically extracts facts from conversations and surfaces them contextually.

// Create assistant with climate expertise
const assistant = await backboardFetch('/assistants', {
  method: 'POST',
  body: JSON.stringify({
    name: 'Planetary Pulse Climate Assistant',
    system_prompt: `You are a climate science expert...`,
    model: 'google/gemini-2.0-flash',
  }),
});

// Each message auto-persists state + memory
const response = await backboardFetch(`/threads/${threadId}/messages`, {
  method: 'POST',
  body: JSON.stringify({ content: message, stream: false }),
});

The frontend shows a "Persistent Memory" panel displaying extracted facts in real-time. When the assistant says "I remember you drive an EV — that's already ahead of average!" — that's Backboard working.

🟠 Auth0 for Agents — Security That Delegates

Auth0 handles user login and mints scoped tokens for the AI agent. Most AI demos skip auth entirely — this one doesn't.

app.use(auth({
  authRequired: false,
  auth0Logout: true,
  baseURL: 'http://localhost:3000',
  clientID: process.env.AUTH0_CLIENT_ID,
  issuerBaseURL: `https://${process.env.AUTH0_DOMAIN}`,
}));

// Scoped agent token for AI delegation
app.get('/api/auth/agent-token', (req, res) => {
  if (!req.oidc?.isAuthenticated()) return res.status(401).json({ error: 'Not authenticated' });
  res.json({ agent_token: req.oidc.accessToken, user_id: req.oidc.user.sub });
});

The pattern: user authenticates → delegates specific capabilities to AI via scoped tokens. The user controls what the AI can see.

🔵 Google Gemini — Structured Intelligence, Not Chatbot Vibes

I don't use Gemini as a chatbot. I use it as a structured analysis engine. Three endpoints, each with a specific JSON schema:

// POST /api/gemini/analyze — structured climate metric analysis
// POST /api/gemini/personal-plan — personalized action plans
// POST /api/gemini/interpret-data — human-readable data interpretation

const response = await fetch(`${GEMINI_URL}?key=${GEMINI_API_KEY}`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    contents: [{ parts: [{ text: analysisPrompt }] }],
    generationConfig: { temperature: 0.7, maxOutputTokens: 2048 },
  }),
});

The key insight: schema-first prompting. I define the exact JSON shape I want and Gemini reliably returns parseable output. No regex parsing, no fragile text extraction. The AI Insights panel renders directly from Gemini's structured response.

🔷 Snowflake — Seven Real Datasets, Not Toy Data

// Parameterized queries with year filtering
let sql = `SELECT year, value, source FROM ${dataset}_data WHERE 1=1`;
if (fromYear) sql += ` AND year >= ?`;
if (toYear) sql += ` AND year <= ?`;
sql += ` ORDER BY year`;

Seven datasets spanning 1880–2024 from authoritative sources:

🟣 Solana — Proof of Impact on Chain

When you retire a carbon credit, it's not just a button click — it's a real Solana transaction you can verify on Explorer.

const burnTx = new Transaction().add(
  createBurnInstruction(
    creditTokenAccount, CREDIT_MINT,
    keypair.publicKey, tonnes * 1e9
  )
);
const signature = await connection.sendTransaction(burnTx, [keypair]);

The marketplace shows four credit types (Amazon Reforestation, Texas Wind Farm, Indonesia Mangrove, Direct Air Capture) with real pricing and certification standards. Each retirement updates your cumulative impact: trees planted, car miles offset, flight hours neutralized.

🟢 GitHub Copilot — The Weekend Multiplier

Copilot didn't just autocomplete — it changed what was possible in 48 hours. Here's exactly what it handled:

I'd write a comment like // Calculate carbon footprint for car commute: distance km, days per week and Copilot would generate the full function with IPCC-calibrated factors. The trick is knowing what to ask and always reviewing what it generates.

Without Copilot, this is a one-week project. With it, I shipped in a weekend.

Prize Categories

This submission qualifies for all six prize categories:

What I Learned

1. Backboard's auto-extraction is the future of AI assistants. No manual memory management — it just works. This is how every AI app should remember users.

2. Structured output > free-form prompting. Schema-first Gemini calls produce reliable, parseable JSON every time. I'll never go back to regex-parsing chatbot responses.

3. Mock fallbacks aren't a hack — they're architecture. Building dual-path (live API → cached fallback) from the start made the entire app demo-proof. No "it works on my machine."

4. Solana devnet surprised me. Expected blockchain friction, got instant transactions and a real explorer. The UX gap between "retire a credit" and "see the tx on Solana Explorer" is 3 seconds.

5. Copilot changed my project scope. What used to be "build a dashboard" became "build a dashboard + AI assistant + calculator + blockchain marketplace" — because the boilerplate was free.

6. Auth0 for Agents is the missing piece in AI apps. Most demos skip auth. Scoped tokens enable real delegation patterns where users control what the AI can access.

What Makes This Different

Most Earth Day submissions fall into two buckets: "here's a carbon calculator" or "here's an AI chatbot about nature." Planetary Pulse is different because:

• The data is real — 7 datasets from NASA, NOAA, WWF spanning 144 years
• The AI remembers — Backboard gives the assistant cross-session memory
• The blockchain is real — actual Solana transactions, not just a UI mockup
• The app works everywhere — zero-config mock fallbacks mean no broken demos
• Six technologies, one story — not six integrations bolted together, but six solutions to six real problems

Future Enhancements

• Real-time WebSocket data feeds from live climate APIs
• Community leaderboards and shared climate goals
• Mobile PWA for install-on-home-screen experience
• MCP integration for the Auth0 + Backboard agent

The planet is worth building for. 🌍💚