DEV Community: ujja

PlanetLedger — Turning Spending Into Environmental Awareness

ujja — Sat, 18 Apr 2026 16:44:53 +0000

This is a submission for Weekend Challenge: Earth Day Edition

What I Built

PlanetLedger — an AI-powered sustainability finance dashboard that turns your bank statements into environmental intelligence.

You upload a CSV or PDF bank statement, and an agent pipeline automatically:

Parses every transaction and categorises it against 20+ real Australian vendors (Woolworths, Chemist Warehouse, Didi, City Chic, Skechers, Aldi, IGA and more)
Assigns a planet impact score (GREEN / YELLOW / RED) per transaction based on category and spend size
Aggregates spend into a category breakdown — Fast Fashion, Grocery, Transport, Electronics, Hygiene, Food Delivery
Runs a RAG-grounded insight pipeline that generates personalised recommendations using your actual spending context
Shows a gamified Planet Impact Score dial (0–100) with unlockable badges (Conscious Spender → Low Impact Week → Planet Saver)
Lets you chat with your personal agent ("Why is my impact high? What should I cut?")
Runs a What-If Simulator — drag a slider and instantly see how cutting food delivery by 30% changes your score
Tracks a memory timeline so the agent learns your patterns week over week
Has a public /demo page — no login required, try it with sample AU data before signing up
The sample data is Australian, but any CSV using the Date / Transaction / Debit / Credit / Balance schema works — regardless of which bank or country it comes from

The goal: make the invisible environmental cost of everyday spending visible and actionable — in seconds, not spreadsheets.

Demo

👉 Try the live demo — no login needed

Or sign in to upload your own AU bank statement (CSV or PDF) and get a personalised dashboard.

Code

ujjavala / PlanetLedger

PlanetLedger

PlanetLedger is an agent-first sustainability finance dashboard that turns bank statements into environmental intelligence. Upload a CSV or PDF and get a personalised impact score, AI-powered insights, and adaptive recommendations — powered by an in-process event pipeline, Auth0 with FGA, and a persistent agent memory system.

Flow: User → Auth0 → PlanetLedger Agent → OpenClaw Pipeline → Insights + Notifications → UI

Stack

Layer	Tech
Framework	Next.js 15.5 App Router + TypeScript
Auth	Auth0 v4 (`@auth0/nextjs-auth0`) — middleware-based, zero route handlers
AI / LLM	LangChain + OpenAI `gpt-4o-mini` / Google Gemini `gemini-1.5-flash` (fallback)
Rules engine	Custom categorisation + scoring — deterministic, explainable
RAG	Context builder that grounds prompts in real spend data
PDF parsing	`pdf-parse` v2 + AU bank statement regex extractor
Event bus	OpenClaw — homegrown in-process event-driven workflow runner
Cron	Vercel Cron (`vercel.json`) — weekly report every Monday 09:00 UTC
Styling	Tailwind CSS,

…

View on GitHub

How I Built It

Stack

Layer	Tech
Framework	Next.js 15.5 App Router + TypeScript
Auth	Auth0 v4 (@auth0/nextjs-auth0) — middleware-based, zero route handlers
AI / LLM	LangChain + OpenAI gpt-4o-mini (primary) / Google Gemini gemini-1.5-flash (fallback)
Rules engine	Custom categorisation + scoring — deterministic, explainable, free
RAG layer	Context builder that grounds prompts in real spend data
PDF parsing	pdf-parse v2 + AU bank statement regex extractor
CSV parsing	papaparse + AU format (Date / Transaction / Debit / Credit / Balance)
Event bus	OpenClaw — homegrown event-driven workflow runner
Styling	Tailwind CSS v3, Space Grotesk font
Deployment	Vercel

The Agent Pipeline

Five layers run in sequence every time you upload:

1. Parse
The CSV/PDF parser extracts raw rows into a typed Transaction[]. For PDFs, a regex pass converts raw AU bank text (dates like 03 Dec 2022, amounts, CR/DR markers) into the same CSV format before parsing.

2. Categorise
resolveCategory() maps merchant names to one of seven categories using regex + keyword matching against known AU vendors. Anything it can't match falls through to an LLM reclassification call (OpenAI or Gemini, temperature=0, 10 tokens max — cheap and fast).

3. Score
calculateImpactScore() runs the scoring engine:

GREEN transaction → +10 pts, YELLOW → +5 pts, RED → -2 pts
Normalised to 0–100 across transaction count
Preference bonuses: +8 if user owns no car, +3 for low-income mode on RED transactions
Weekly trend: ≥75 = "Improving", 45–74 = "Stable", <45 = "Needs Attention"

4. Build RAG Context
Before any insight or chat response, buildRagContext() pulls together: last 7 days of transactions, top 2 categories by spend, top 3 merchants, and detected behaviour patterns. This context is injected into every prompt so the agent actually talks about your data.

5. Generate Insights
The insight pipeline fires { type: WARNING | POSITIVE | NEUTRAL, message } structured outputs and stores them with a 3-minute cache. Patterns like "3+ food delivery orders in a week" or "fast fashion spend > $50" trigger specific recommendations.

Agent memory persists per-user (keyed by Auth0 sub) and feeds back into the next run — so the agent gets smarter about your habits over time.

Auth0 for Agents

Auth0 v4 runs entirely via Next.js middleware — no /api/auth/* route files needed. One line sets it up:

// lib/auth0.ts
import { Auth0Client } from "@auth0/nextjs-auth0/server";
export const auth0 = new Auth0Client();

// middleware.ts
export async function middleware(request: NextRequest) {
  return auth0.middleware(request);
}

Every API route checks an internal agent scope before doing anything. The scope check is now backed by a fine-grained authorisation (FGA) rule table (lib/auth/fga.ts) that maps resource + action → required scope:

// lib/auth/fga.ts
export function canPerform(scopes: string[], resource: FGAResource, action: FGAAction): boolean {
  const required = FGA_RULES[resource]?.[action];
  return required ? scopes.includes(required) : false;
}

The scopes (read:transactions, write:insights, update:score) live as custom Auth0 claims — not OIDC scopes — which keeps agent permissions cleanly separated from OAuth. User preferences (noCarOwnership, lowIncomeMode) are stored as Auth0 custom claims so they survive across sessions.

A Post-Login Action (lib/auth/actions/post-login.js) provisions new users on first login — setting eco_tier: "starter" in app_metadata, injecting custom claims, and enforcing MFA via api.multifactor.enable("any"). Rolling sessions (inactivityDuration: 1 day, absoluteDuration: 7 days) keep users signed in without requiring frequent re-auth.

The public /demo page and /api/upload/preview are excluded from the middleware matcher, so anyone can try the app without an account.

OpenClaw — the Event Bus

OpenClaw is a lightweight in-process event system I built to wire up automation without reaching for a queue service.

Four workflows register on startup:

Workflow	Event	What it does
autoInsightOnUpload	transactions_uploaded	Runs the full agent pipeline, caches insights
highImpactAlert	high_impact_detected	Pushes in-app alert notification with top offending categories
weeklyReport	weekly_report	Full score + insights digest; pushes weekly notification to the bell
scoreImprovedCelebration	score_improved	Pushes a celebration notification when the score rises after upload

After an upload, openClawChainedTrigger() fires the full sequence: transactions_uploaded → score_calculated → insights_generated → score_improved (if the score increased). The route handler just returns the parsed data immediately while the pipeline runs.

Vercel Cron fires weekly_report every Monday at 09:00 UTC via POST /api/cron/weekly-report, configured in vercel.json.

The /demo Page

One of the things I'm happiest about: the /demo page works with zero auth and zero network calls. It's a Next.js server component that imports the sample CSV data as a TypeScript string constant and calls parseTransactionsCsv() + calculateImpactScore() directly at build time. It prebuilds as a static page — instant load, no middleware, no DB.

Premium features (AI chat, What-If Simulator, Memory Timeline) show as blurred locked panels with a lock icon — so visitors can see what they'd get after signing up.

Earth Day Design Choices

Deep forest green hero gradient — earth tones throughout, nothing corporate-blue
Category breakdown with proportional spend bars instead of raw numbers
Impact score dial animates from red → amber → green when the page loads
Real AU vendor recognition — the shops people in Australia actually use
Every transaction shows its impact colour inline so the pattern is visible at a glance

Interesting Engineering Decisions

Why deterministic rules for categorisation, not LLM?
Rules are fast, free, and traceable. Every categorisation decision has an exact rule you can point to. I use the LLM only for the "Other" fallback bucket — maybe 10–15% of transactions — where a keyword match doesn't exist. That keeps costs near zero and lets the rules engine run at build time on the demo page.

Why an in-memory store?
For a weekend build, an in-memory Map<userId, UserMemory> is zero-infrastructure and good enough for single-server dev. Both stores are now anchored to globalThis.__pl_* keys so HMR hot reloads in dev don't wipe your data. The entire storage layer is behind a lib/store.ts interface — swapping to Redis or Postgres is one function replacement, not an architectural change.

Agent memory specifically uses a file-backed store (.agent-memory/<fnv1a-hash>.json) with 30-day auto-expiry — so the agent's learned patterns survive server restarts, not just hot reloads.

Why AU sample data, and can other countries use it?
The sample data is from an Australian bank (ANZ/CBA-style export), but the parser isn't locked to Australia. Any CSV that follows the Date / Transaction / Debit / Credit / Balance column schema will parse correctly — regardless of the bank or country. The vendor categorisation rules are AU-focused right now (Woolworths, Chemist Warehouse, Didi, etc.), but the categorisation layer is just a map — adding UK, US, or EU merchants is additive. The "Why AU only" answer is really: nailing one set of vendors well beats vague coverage of five markets.

Going Further During the Weekend

The core build came together fast, so I kept pushing. Here's what landed after the initial submission:

Real multi-turn chat with what-if and doc Q&A
The chat engine was keyword-matching and templated. It's now a real multi-turn conversation — conversation history is injected as context so the agent remembers what you asked. You can ask "what if I reduce food delivery by 30%?" and the agent runs an actual score simulation. You can ask "how much did I spend on groceries last week?" and it queries your real transaction data. The RAG scaffolding was already there; wiring it up to GPT-4o was the last step.

File-backed persistent agent memory
Agent memory moved from an in-memory Map (lost on restart) to per-user .agent-memory/<fnv1a-hash>.json files with 30-day auto-expiry. In dev they live at .agent-memory/, in prod at /tmp/planetledger-memory/. The agent's learned patterns now actually survive hotfixes and deploys.

In-app notification bell
OpenClaw's highImpactAlert and weeklyReport were logging to console. Now they push structured notifications to an in-memory store, which a bell component polls every 60 seconds. Three notification types: 📊 Weekly Report, 🌱 Score Improved, ⚠️ High-Impact Alert. The score_improved event is new too — fires automatically when an upload raises your score.

Chained OpenClaw pipeline + Vercel Cron
The upload flow now fires a full event chain: transactions_uploaded → score_calculated → insights_generated → score_improved. One call, four events, all in-process. The weekly report fires via Vercel Cron every Monday 09:00 UTC (vercel.json + /api/cron/weekly-report).

Auth0 FGA, Post-Login Action, MFA, rolling sessions
The flat scope check got replaced with a proper FGA rule table (resource + action → required scope). A Post-Login Action provisions new users on first login and enforces MFA. Rolling sessions mean users stay signed in across the week without re-authing.

Privacy hardening
email and merchant names are no longer stored in UserContext, agent memory, or RAG prompts — they're PII-adjacent and don't need to be there. OpenClaw workflow logs pseudonymize user IDs via FNV-1a hash (usr_XXXXXXXX). A lib/privacy/sanitizer.ts module handles all redaction.

What's Still Next

Persistent database
The transaction store is still in-memory (Map<userId, UserMemory> anchored to globalThis for HMR safety). Agent memory is file-backed now, but transactions, scores, and chat history need Postgres via Prisma for real persistence. The store interface is already abstracted — the migration is mostly additive.

Smart parsing for all countries
The AU bank format is very specific. The next version should detect the bank format automatically — US (Plaid/OFX), UK (Monzo/Starling CSV), EU (SEPA), and AU — and route to the right parser.

Real CO₂ data
Right now impact scores are proxy-based (category + spend → colour). The right approach is to integrate an actual emissions API (like Climatiq or Patch) to get grams of CO₂e per transaction category, so the score means something measurable.

Email / push delivery
In-app notifications work. Email or mobile push (Resend, FCM) would make the weekly report actually reach users where they are.

Mobile-friendly upload
The upload panel works on desktop. A mobile-optimised flow — forwarding a bank statement email directly to PlanetLedger via a Cloudflare Email Worker — would massively reduce friction.

More AI agent capabilities

Goal setting ("I want to reduce fast fashion spend by 40% this month") with progress tracking
Carbon offset suggestions matched to your worst categories
Peer comparison ("people with similar spending reduced food delivery by X%")- Surface proactive nudges (WARNING / TIP / CELEBRATION) from lib/agent/nudges.ts — the engine is built, just needs an API route + UI hook

Prize Categories

Best Use of Auth0 for Agents — Auth0 v4 middleware with zero route handlers; FGA rule table (resource + action → scope) backing every agent action; Post-Login Action provisioning with MFA enforcement; rolling sessions (inactivityDuration + absoluteDuration); custom claims for preferences, eco_tier, and organization_id; scope check on every API route before any agent action runs.
Best Use of GitHub Copilot — Used end-to-end: scaffolding the agent pipeline, writing AU vendor categorisation rules, building the PDF regex extractor, generating type-safe API routes, implementing the FGA rule table and privacy sanitizer, designing the notification bell + polling architecture, building the chained OpenClaw pipeline, and iterating on UI components throughout.

Revisiting Idris in 2026: Is It Ready for Real Work?

ujja — Tue, 14 Apr 2026 00:19:30 +0000

Idris has always promised something bold: encode correctness directly into the type system. In 2026, with Idris 2 firmly established, it’s worth revisiting whether that promise translates into production-grade reality.

Short answer: yes, in the right places.

Idris 1 vs Idris 2

Idris 1

Proof-of-concept era
Slow compiler, heavy memory usage
Research-focused ergonomics
Effectively legacy

Idris 2

Complete reimplementation
Faster compilation and smaller core
Multiple backends (Chez Scheme default, C available)
Actively maintained and stable

If you’re evaluating Idris today, Idris 2 is the only sensible choice.

The core idea, in code

Idris doesn’t just type-check values — it type-checks facts.

Length-safe vectors

data Vect : Nat -> Type -> Type where
  Nil  : Vect 0 a
  (::) : a -> Vect n a -> Vect (S n) a

Concatenation proves length correctness:

append : Vect n a -> Vect m a -> Vect (n + m) a
append Nil       ys = ys
append (x :: xs) ys = x :: append xs ys

No runtime checks. The compiler enforces the invariant.

Totality: making partial logic illegal

total
head : Vect (S n) a -> a
head (x :: _) = x

This function cannot be called on an empty vector. Invalid states are unrepresentable.

Idris 2 ergonomics (the nitty-gritty)

Compiler & performance: Significantly faster than Idris 1, reasonable compile times
Error messages: Improved structure, still proof-oriented and verbose
Tooling: LSP support exists, interactive editing is powerful, docs are uneven

Usable, but not luxurious.

Linearity and resource safety

useOnce : (1 x : a) -> a
useOnce x = x

Linear types enable compile-time guarantees around resource usage: no double-use, no leaks, no implicit copying.

Is Idris ready for production?

Where Idris shines

Protocols and state machines
Parsers, DSLs, validation-heavy logic
Compilers and interpreters
Correctness-critical business logic

Where it struggles

Small ecosystem
Hiring challenges
Interop overhead
Not ideal for fast-moving CRUD apps

Idris works best as a correctness core, not a default full-stack choice.

Mainline development or niche tool?

Idris isn’t trying to replace Go, Rust, or TypeScript.

It’s for teams asking:

What if the compiler enforced our invariants?
What if tests were secondary to types?

In 2026, Idris 2 is stable enough for real systems, if your team is willing to think in types.

Final take

Idris is no longer just a research curiosity.

Idris 2 is production-capable for the right domains, offering unmatched guarantees at compile time.

If correctness is your top priority, Idris is quietly excellent.

Fourbidden: A Serious AI Solution to 2+2, With Maximum Ceremony and No Resolution

ujja — Sun, 05 Apr 2026 10:04:34 +0000

This is a submission for the DEV April Fools Challenge

What I Built

I built Fourbidden, a fake AI product dedicated to solving one extremely serious global problem: 2+2.

The joke is that the problem could not be smaller, but the app treats it like the final summit of machine reasoning.

You ask a basic addition question, and instead of getting a basic addition answer, the app starts trying to sum up its own importance.

That means you get:

AI-generated loading statements that sound suspiciously strategic
circular explainers that get more philosophical and less useful over time
escalating terms and conditions that keep turning arithmetic into a compliance event
procedural next steps designed to preserve momentum without producing closure
dashboard widgets, warnings, and theatrical system language
surprise interactions like panic overlays, chaos toasts, prank label swaps, and a hidden Konami-style chaos mode

The T&C bit became one of my favorite parts of the whole thing.

The user is effectively told that before they can move closer to understanding 2+2, they must first acknowledge expanding legal nonsense, accept more conditions, and agree to one more procedural step. Then another. Then another.

So the core gag is not just overengineering. It is over-addition: treating the smallest possible math question like a high-risk, high-governance product flow.

It is a satire of software that cannot simply give you the answer, because it is too busy building a whole process around the answer.

Demo

Live demo: https://ujjavala.github.io/fourbidden/
Local version: http://localhost:3000
Main routes:
- Home: /
- About: /about
- Services: /services

Code

GitHub: https://github.com/ujjavala/fourbidden

Key route surface:

/api/explain
/api/loading
/api/terms
/api/steps
/api/loop
/api/widgets

How I Built It

I wanted the app to feel like a glossy software product that exists entirely to avoid resolving 2+2 in a straightforward way.

So instead of making a single punchline screen, I built a full fake workflow around the idea of “solving” the problem while constantly refusing to complete it.

Tech stack:

Next.js 14 (App Router)
React + TypeScript
Google AI (Gemini API) to generate the app's overblown explanations, loading copy, legal nonsense, escalation steps, loop logic, and widget chatter
Custom CSS for the bright cinematic UI, orbit effects, shimmer, flashes, and overly dramatic motion
Lucide React for icon-driven UI accents

Implementation choices that shape the vibe:

The main joke is taking the tiniest math problem and inflating it into a full-stack event.
The interface looks polished enough to imply a seed round and a brand strategy deck.
The T&C flow is central to the bit: the user keeps having to consent to more nonsense before progress can allegedly continue.
The text stays intentionally circular and jargon-heavy so the app never gives the satisfaction of a clean conclusion.
The click surprises add a second layer of April Fools chaos on top of the main workflow.
There is a static fallback path so the absurdity still works even when live AI calls are unavailable.

How I Leveraged Google AI

Gemini is the narrative engine for the whole product illusion.

I did not use it as a single chatbot response. I split the experience into multiple AI-backed roles so each part of the fake platform has its own voice and function.

/api/explain: produces long-form ceremonial non-answers
/api/loading: turns waiting into executive messaging
/api/terms: creates useless compliance clauses and acceptance loops around 2+2
/api/steps: invents process-heavy next actions
/api/loop: explains why completion is still not operationally appropriate
/api/widgets: generates fake platform telemetry and side-channel noise

To keep that experience stable, I added:

prompt caching with a short TTL
retry and backoff handling for quota and rate-limit failures
local fallback generators when Gemini is unavailable
client-side static mode for static hosting environments

That way the joke survives whether the AI is live, rate-limited, or completely absent.

Prize Categories

Best Google AI Usage

Google AI is not just providing flavor text here. It is powering the entire illusion that a hopelessly overbuilt software stack has been assembled to “solve” a single grade-school math prompt. Every stage of that ridiculous journey gets its own AI-generated nonsense.

Best Ode to Larry Masinter

This app is proudly unnecessary. It manufactures protocol, ceremony, terms, gates, and pseudo-serious internet behavior around a task that should end instantly. It feels like the kind of thing that technically works while making arithmetic worse.

Community Favorite

I think the joke lands quickly: everyone understands 2+2, and everyone also recognizes software that delivers process instead of outcomes. Combining those two ideas made it easy to build something immediate, silly, and annoyingly plausible.

If it makes people laugh and also mutter, "why does this feel plausible," then it did its job.

[Boost]

ujja — Fri, 20 Mar 2026 11:35:27 +0000

Notion MCP Challenge Submission 🧠

ujja

Mar 12

I Built EchoHR: The HR System That Doesn’t Ghost You

#devchallenge #notionchallenge #mcp #ai

Comments 63

5 min read

Big drop for EchoHR 🚀 🔧 Postgres queue + worker, idempotent + HMAC webhooks, retries/backoff, metrics ✨ Cleaner UX with hero video, logo, and clearer lifecycle ⚙️ More reliable setup + Docker flow (migrate seed worker) Check out the blog for more 👇

ujja — Tue, 17 Mar 2026 06:08:56 +0000

Notion MCP Challenge Submission 🧠

ujja

Mar 12

I Built EchoHR: The HR System That Doesn’t Ghost You

#devchallenge #notionchallenge #mcp #ai

Comments 63

5 min read

The Enablers Who Helped Me Code Forward

ujja — Tue, 10 Mar 2026 03:31:44 +0000

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

Sometimes the difference between giving up and moving forward is just one person who believes in you.

I started coding when I was around nine years old.

My first program was written in LOGO, where I spent hours writing tiny programs using a funny-looking triangular turtle that moved across the screen. You could tell it to move forward, turn, and draw shapes, and slowly patterns would emerge. To a kid, it felt magical. A few instructions and suddenly the computer was drawing something I had imagined.

Back then I had no idea what a career in tech looked like. I just knew I loved making computers do things.

One thing that made my journey different from many stories I hear today was the support I received at home. My family, especially my dad, supported my interest in computers wholeheartedly. At a time when many people still questioned whether girls should pursue technology, he never did. To him it was simple — if I enjoyed it, I should pursue it.

That early encouragement made a huge difference.

The Myth of the Solo Journey

When people talk about careers in tech, the story is often about individual effort — perseverance, hard work, determination.

And while those things matter, looking back I realise something else played an equally important role: enablers.

Throughout my journey there were always people who gave me a small push forward at the right moment.

Not huge dramatic gestures. Just small nudges that made a big difference.

The First Catalyst

Early in my career I had a tech lead who noticed something about me before I fully recognised it myself.

I loved clean code.

I loved experimenting.

Hackathons excited me.

Instead of letting that remain just a personal interest, he organised a hackathon within the team.

At the time it seemed like just a fun activity. But in reality, it gave me confidence. It validated that my curiosity and enthusiasm for building things mattered.

Sometimes all someone needs is that small signal that their passion is worth investing in.

Finding My Voice

Later in another organisation I faced a different challenge.

I was technically confident, but public speaking terrified me.

Speaking up in meetings, presenting ideas, addressing a room full of people — those things didn't come naturally to me.

An office head in that organisation noticed this and gently pushed me out of my comfort zone.

Encouraging me to present.

Encouraging me to speak up.

Encouraging me to trust my voice.

I still remember a very simple piece of advice he gave me.

He said, “Start small. Just say hi to people in the morning.”

His reasoning was simple. If I greeted people in the hallway or by the coffee machine, when I later saw them in a meeting room they wouldn’t feel like strangers anymore. The room would feel a little less intimidating.

He also said something that stuck with me — smile. Maybe crack a small joke to ease the tension.

It sounded almost too simple at the time, but it worked. Slowly those rooms full of unfamiliar faces started turning into rooms with colleagues I already knew, even if only through a quick morning hello.

And little by little, speaking up didn’t feel so scary anymore.

Today I speak about topics I care deeply about, especially identity and authentication in tech — something I am incredibly passionate about.

The Reality of Being Heard

If you’ve worked in tech long enough, you’ve probably seen this happen.

Sometimes a woman's voice is ignored.

Ideas get overlooked.

Comments go unheard.

Credit sometimes travels in unexpected directions.

It happens.

But another truth exists too.

There are also people who amplify voices.

People who pause the room and say,

"I think she was making a really good point."

People who make sure ideas get the attention they deserve.

Over time I’ve realised the tech industry isn't defined only by the people who silence voices.

It’s also shaped by the people who make sure those voices are heard.

Recognising the Enablers

Even today in my current workplace I am fortunate to work with amazing people who create that kind of environment.

Looking back, my journey was never just about learning new technologies, frameworks, or systems.

It was also about recognising the people who helped me move forward.

The enablers.

The mentors.

The leaders.

The colleagues.

The allies.

The people who saw potential and helped unlock it.

Paying It Forward

The biggest lesson from my journey is this:

If you’ve had enablers in your life, the best thing you can do is become one for someone else.

Encourage the curious junior developer.

Support the quiet voice in the meeting.

Create spaces where people can experiment and grow.

Sometimes a small push can change someone’s entire trajectory.

I know it did for me.

And to all the girls who want to code but feel like they can’t,

to all the women and marginalised voices who sometimes feel unheard or silenced in tech:

Look around.

There are often people who quietly support you, encourage you, and believe in you — sometimes even before you believe in yourself.

Find those people.

Recognise them.

Hold on to them.

Because once you identify the enablers in your life, you’ll realise something powerful. You were never coding alone.

And if you ever feel like you don’t belong in tech, remember this:

Sometimes all it takes is one enabler to change your trajectory — and someday, that enabler might be you.

Rethinking AI Assistants: A Privacy-First Approach with Google Gemini

ujja — Wed, 04 Mar 2026 11:09:32 +0000

Built with Google Gemini: Writing Challenge

ujja

Feb 28

Building a Privacy-First Mobile Speech Assistant Using Google Gemini

#devchallenge #geminireflections #gemini #llm

Comments 14

5 min read

CommonGround: Designing Digital Spaces for Safety, Healing, and Connection

ujja — Wed, 04 Mar 2026 11:08:35 +0000

DEV Weekend Challenge: Community

ujja

Feb 28

Building Safer Online Spaces with CommonGround

#showdev #devchallenge #weekendchallenge

Comments 1

4 min read

What It Really Takes to Migrate 20+ Domains and 100+ SQL Tables from .NET to GraphQL

ujja — Wed, 04 Mar 2026 11:07:25 +0000

ujja

Feb 27

How We’re Surviving 20+ Domains and 100+ SQL Tables While Migrating Our Legacy .NET Backend to GraphQL

#csharp #typescript #docker #dotnet

Comments

5 min read

Tech for good, built and shared on DEV 💛. I built a stutter-friendly app for calm, supportive, judgment-free speaking practice, with gentle feedback and privacy-first design at its core. Built with Elm, Elixir, and Copilot CLI. Thoughts?

ujja — Fri, 20 Feb 2026 23:22:59 +0000

GitHub Copilot CLI Challenge Submission

ujja

Feb 14

I built a Stutter-Friendly App in 1 Day with Elm, Elixir, and Copilot

#devchallenge #githubchallenge #cli #githubcopilot

Comments 16

9 min read

Is Creativity Dying in the Age of AI-Generated Websites?

ujja — Wed, 18 Feb 2026 02:49:22 +0000

Lately, I’ve been noticing a curious trend. I visit one website, and then another, and… it’s almost the same. Layouts feel eerily familiar, interactions feel almost identical, and the overall "feel" is uncanny. What’s even more striking is that many of these sites have emerged in just the last year or two.

It makes me wonder. Is AI actually stifling creativity? Or is it just accelerating convergence in design?

Many of these websites appear to be built end-to-end with AI-assisted tools. From layout to copy to interaction patterns, it feels like someone hit a "VibeCode" button and got the whole package. The upside is obvious. Faster development, consistent quality, and lower cost. The downside? They all start to look and feel the same.

I could be wrong, but it seems like the proliferation of these AI-driven templates might be leading to a kind of homogenisation. The uniqueness that used to come from a designer’s experimentation or a developer’s creative twist is now being replaced by AI "best practices."

That’s not to say AI is inherently bad for innovation. It can supercharge ideas, help smaller teams punch above their weight, and unlock possibilities that were previously too time-consuming. But if everyone leans too heavily on AI-generated defaults, we might end up in a world where every new site looks like a slightly different clone of the last one.

So maybe the real challenge isn’t AI itself. It’s how we use it. If we rely on it blindly, innovation can stagnate. But if we treat it as a creative partner, a tool rather than a template factory, there’s still room for fresh ideas, bold experiments, and genuine originality.

The question I keep coming back to is this. In a world where AI can do "most of it" automatically, how do we ensure we’re still pushing boundaries instead of just reproducing what already exists?

Sharing this because the mission matters 💛 I built a stutter friendly app that makes speaking practice calm, supportive, and judgment free, with gentle feedback and privacy first design at its core. It's built with Elm, Elixir, and Copilot CLI. Thoughts?

ujja — Sun, 15 Feb 2026 22:01:16 +0000

GitHub Copilot CLI Challenge Submission

ujja

Feb 14

I built a Stutter-Friendly App in 1 Day with Elm, Elixir, and Copilot

#devchallenge #githubchallenge #cli #githubcopilot

Comments 16

9 min read