DEV Community: Mohammad Ali Abdul Wahed

The Code Was in Git. The AI Conversations TO Implement it,Was Gone

Mohammad Ali Abdul Wahed — Sat, 04 Jul 2026 03:38:11 +0000

I reopened an old project and found a working authentication implementation.

What I could not find was the reason it looked that way.

The commits showed the final code, but not:

Why one approach had been chosen
Which fixes had already failed
What the coding agent warned me about
Which tasks had been postponed

The answers were scattered across a ChatGPT thread, a Codex session, and a terminal that no longer existed.

There was another layer to it. I don't stick to one agent. I move between Codex, Claude Code, Cursor, and plain ChatGPT threads — sometimes because one tool genuinely fits the task better, more often because I simply run out of credits on one and switch to another mid-task. Every time that happened, the new agent started from zero. It had no idea what the previous one had already tried, decided, or ruled out. I either re-explained everything from memory, or let the new agent guess and re-discover things the old one already knew.

This is not only a documentation problem. It is a structural problem in AI-assisted development.

We use several tools to produce one project, but every tool keeps a separate, temporary memory.

That experience became ContextVault.

First: what is ContextVault?

ContextVault is an open-source, local-first memory layer for AI work.

It preserves useful context from browser LLM conversations, terminals, and coding-agent sessions, then makes that context searchable and reusable in later sessions.

Think of the distinction this way:

Git:          what changed in the code?
ContextVault: why did we change it, what failed, and what should happen next?

The trigger for building it was specifically the agent-switching problem: whenever one agent ran out of credits or hit a limit, I needed the next one to pick up exactly where the last one left off, instead of restarting the investigation.

ContextVault has three user-facing surfaces:

Browser Capture — a Chrome extension that stores supported LLM conversations locally and exports Markdown or ZIP.
Vault Terminal — an npm CLI for recording agent work, decisions, tasks, problems, and notes inside a project.
ContextVault Desktop — a visual app for recording, browsing, retrieving, preparing, and exporting that project context.

There is no required account or ContextVault backend. Browser data stays in the browser. Project sessions stay in local Markdown.

A concrete example

Initialize ContextVault inside a repository:

npx @aliabdm/contextvault init
contextvault record

During the session, preserve only the context that may matter later:

/title Fix authentication callback
/source codex
/user The login redirects back to the sign-in page.
/agent The session cookie is missing during the callback.
/decision Keep authentication checks in middleware.
/problem The previous SameSite change did not fix the callback.
/task Add a regression test for the redirect loop.
/end

The result is readable Markdown under:

.contextvault/sessions/

Later, a developer or agent can ask for evidence:

contextvault history --since 2w
contextvault decisions auth --source codex
contextvault problems auth --since 30d
contextvault retrieve "authentication callback"
contextvault prepare "fix authentication callback"

retrieve ranks relevant local events. prepare creates a focused Markdown package for the next agent.

The current engine is deterministic and lexical. It does not send the project to an LLM or generate an ungrounded answer.

Why build a Desktop app?

The CLI proved the model, but it limited the audience.

Someone who simply wants "authentication decisions from the last month" should not need to know this syntax:

contextvault decisions auth --source codex --since 30d

So I built an Electron app over the package.

The first version exposed command buttons and a raw arguments field.

Technically, this preserved package compatibility. From a UX perspective, it was still asking users to think like a shell parser.

The app was a GUI, but not yet a Desktop product.

The redesign goal became similar to Docker CLI and Docker Desktop:

Share the engine and data model, but give each surface a complete experience.

The dangerous shortcut: implementing everything twice

The easiest way to build the GUI would have been to give Desktop its own recorder and database:

CLI      -> Markdown
Desktop  -> SQLite or custom JSON

That would immediately create two versions of ContextVault.

Sessions, migrations, bug fixes, and indexing behavior would eventually drift. Existing CLI users would need imports or conversions before using Desktop.

Instead, the architecture keeps one source of truth:

Browser exports       CLI / agents       Desktop recorder
       \                   |                    /
        \                  |                   /
                 .contextvault Markdown
                           |
                    local Context Engine
                           |
       History · Search · Retrieve · Prepare · Memory

Desktop is a GUI over the same engine and files—not a second implementation.

How recording works inside Electron

When the user clicks Start recording, the Electron main process launches the bundled package recorder with the selected project as its working directory.

The renderer only receives a narrow preload API:

startRecorder({ title, source })
sendRecorderCommand(recorderId, command)
finishRecorder(recorderId)
cancelRecorder(recorderId)

An entry created in the GUI is sent to the real recorder:

await window.contextVault.sendRecorderCommand(
  recorderId,
  `/decision ${content}`,
)

The package writes the final session Markdown.

This means a session created in Desktop is visible to:

contextvault list
contextvault show <session-id>

No conversion step is required.

How CLI sessions appear live in Desktop

Compatibility also needs to work in the opposite direction.

The main process watches the active project's session directory:

vaultWatcher = watch(sessionsPath, () => {
  if (vaultRefreshTimer) clearTimeout(vaultRefreshTimer)

  vaultRefreshTimer = setTimeout(async () => {
    const engine = await getEngine()
    engine.buildContextIndex(projectPath)
    mainWindow?.webContents.send('contextvault:vault-changed')
  }, 250)
})

The delay debounces bursts of file events. After rebuilding the index, open renderer views refresh.

The UI exposes the watcher state:

Watching project
Last updated
Events found
Sources detected

For the integration test, I kept Desktop open and recorded a session from the external CLI. Without reopening the app, the session count increased from 3 to 4, the event count increased from 14 to 16, and terminal appeared as a detected source.

That was the moment the CLI and GUI stopped feeling like separate products.

Turning commands into actual workflows

The redesign replaced the default arguments field with screens based on user intent.

What the user wants	Desktop workflow
Capture project context	Recorder
Browse or export a session	Sessions / Session Detail
Understand recent activity	History
Find previous choices	Decisions
Review bugs and failed attempts	Problems
Review follow-up work	Tasks
Rank evidence for a question	Retrieve
Find matching text	Search
Build context for another agent	Prepare
Connect related sessions	Link Sessions
Maintain the local vault	Index, Memory, Timeline, Export

History, for example, supports:

Since: 24 hours, 7, 14, or 30 days, all time, or a custom date
Source: Codex, Claude Code, Cursor, ChatGPT, manual, terminal, or browser
Event type: decision, problem, task, note, user, or agent
Maximum results

Results are grouped, readable, copyable, and exportable.

The raw runner still exists inside collapsed Advanced CLI Mode for uncommon flags. It is no longer the normal experience.

Search, Retrieve, and Prepare are different

These features can sound interchangeable, so the UI and documentation separate them:

Search

Find matching events and sessions using text and filters.

Retrieve

Rank the local evidence most relevant to a task. The deterministic scorer considers exact phrases, tokens, event importance, recency, and filters.

Prepare

Turn retrieved evidence into a portable Markdown context package for the next model or agent.

ContextVault does not currently pretend to answer a project question using an AI model. It retrieves inspectable evidence and lets the user decide where to send it next.

What "automatic" does and does not mean

ContextVault Desktop automatically notices compatible sessions written into the watched vault.

It does not silently intercept every unrelated Codex, Claude Code, Cursor, VS Code, terminal, screen, clipboard, or microphone process.

An external tool currently appears automatically only if it:

Records through the ContextVault CLI, or
Writes a compatible session file into .contextvault.

Direct agent adapters and an MCP server are future integrations.

This boundary is intentional. Local-first software should not hide its capture behavior behind vague marketing language.

Verification beyond "it builds"

The release was checked across the entire compatibility story:

Package and extension tests          63 passed
Browser extension production build  passed
Desktop renderer type-check          passed
Desktop production build            passed
Windows installer packaging         passed
GitHub Actions Windows build         passed
GitHub Actions Linux build           passed
CLI -> open Desktop live refresh     passed

The Desktop release became v1.8.0. The npm package remained v1.3.0 because the Desktop-only changes did not modify the published package code.

Next: collaborative context repositories

The next phase is Git-like collaboration for context:

Push a selected vault to a repository
Invite collaborators
Pull shared context
Review diffs and history
Edit locally
Push reviewed changes
Resolve conflicts

The difficult part is not remote storage. It is preserving provenance, reviewability, and user ownership while several humans and agents modify shared project memory.

Try ContextVault

npx @aliabdm/contextvault init
contextvault record

GitHub: https://github.com/aliabdm/ContextVault
Desktop: https://context-vault-two.vercel.app/download
Product walkthrough: https://context-vault-two.vercel.app/
npm: https://www.npmjs.com/package/@aliabdm/contextvault
Technical FAQ: https://context-vault-two.vercel.app/faq
Portfolio: https://senior-mohammad-ali.vercel.app/
LinkedIn : https://www.linkedin.com/in/mohammad-ali-abdul-wahed-1533b9171/

ContextVault: Own Your AI Context Across Models, Agents, and Time

Mohammad Ali Abdul Wahed — Sat, 27 Jun 2026 20:00:42 +0000

From Conversation Recorder to Context Engine: Building Local-First Memory for AI Development

How ContextVault 1.3 unifies browser conversations, terminal sessions, and coding-agent decisions in one searchable local context engine — without a backend, tracking, or hidden AI calls.

You spend forty-five minutes walking a coding agent through a Redis connection bug. Together, you find the root cause, test a fix, and uncover a configuration detail that is not documented anywhere. Then the context window fills up. Two weeks later, the same bug appears in staging. The original session is gone, the browser conversation is buried, and the next agent knows nothing about what you already discovered. You start again. This is context fragmentation: project knowledge scattered across ChatGPT conversations, coding-agent sessions, terminals, accounts, models, and limited context windows. It creates a quiet tax on every AI-assisted workflow.

Exporting conversations helps, but only partially. A directory full of Markdown exports is still a directory full of disconnected files. The information is preserved, but it is not organized as project memory. That distinction changed the direction of ContextVault. What began as a browser conversation recorder evolved into a local-first context engine designed around a broader idea:

Git tracks code. ContextVault tracks context.

Why Exporting Conversations Is Not Enough

I originally built ContextVault as a Chrome extension for capturing conversations across multiple LLM platforms. The extension solved an immediate problem: preserving complete conversations locally and exporting them in portable formats.

But capturing browser conversations addressed only one surface.

The decisions that shaped a project were also happening inside Codex sessions, Claude Code investigations, Cursor workflows, terminal debugging, human notes, failed experiments, and task discussions. Those sessions often disappeared when a terminal closed or an agent reached its context limit.

I did not need another folder of exports. I needed a way to preserve what happened, classify it, search it, and prepare it for the next agent.

That led to three connected layers:

Browser Capture
Vault Terminal
The Unified Context Engine

Layer One: Building Browser Capture

Browser Capture is the original ContextVault surface. It is a Chrome Manifest V3 extension that captures conversations from ChatGPT, Claude, Gemini, Perplexity, Poe, DeepSeek, and Copilot.

The extension uses a hybrid DOM and network capture strategy. It watches provider DOM mutations, observes supported network responses, assembles streamed messages in the content-capture layer, and sends finalized messages to the background service worker for local storage.

This hybrid approach matters because LLM interfaces are dynamic. Assistant responses arrive incrementally, DOM elements change while streaming, and provider implementations differ.

Once captured, conversations remain in IndexedDB by default. Users can export them as individual Markdown files or bulk ZIP archives. Each exported conversation includes YAML frontmatter containing metadata such as platform, model, date, conversation ID, and tags.

The data flow is intentionally contained:

Provider page
    ↓
DOM and supported network capture
    ↓
Stream assembly
    ↓
Background service worker
    ↓
Local IndexedDB storage
    ↓
Explicit Markdown or ZIP export

The extension does not send captured conversations to a ContextVault server because no ContextVault server exists. It does not require an account, collect telemetry, or call an external AI API.

Browser Capture solved the first problem: preserving conversations. It did not yet solve project memory.

Layer Two: Building Vault Terminal

Browser conversations are only part of an AI development workflow. Important context also appears while working with coding agents and terminals: a failed authentication fix, a decision about middleware boundaries, an unresolved production problem, a task discovered during debugging, a note explaining why one approach was rejected.

Vault Terminal provides an explicit way to record those moments. It is a Node.js CLI published on npm as @aliabdm/contextvault.

Run it directly without installing anything globally:

npx @aliabdm/contextvault init

Or install globally:

npm install -g @aliabdm/contextvault
contextvault init

To start recording:

contextvault record

Inside the recorder, context is entered using typed commands:

/source codex
/title Fix auth middleware

/user The login redirect is broken.

/agent I found the issue in middleware order.

/decision Keep auth checks in middleware and policy checks in controllers.

/task Add a regression test for the redirect loop.

/problem The session cookie is missing on callback.

/end

These commands become structured context events. Each session is saved as a local Markdown file under .contextvault/sessions/. The files are human-readable, inspectable, searchable with standard tools, easy to archive, and ignored by Git by default.

There is no automatic summarization, rewriting, or external model call. Vault Terminal records what you explicitly provide. It does not intercept every terminal process or automatically capture complete Codex, Claude Code, or Cursor sessions. That limitation is deliberate and visible.

The CLI also supports:

contextvault list
contextvault search "Redis"
contextvault export

Vault Terminal solved the second problem: preserving agent work, decisions, tasks, problems, and notes outside the browser.

The next challenge was connecting both capture surfaces.

Layer Three: Building the Unified Context Engine

The Unified Context Engine turns separate captures into searchable project context. It imports Browser Capture exports, reads Vault Terminal sessions, normalizes both sources into shared models, and builds a local index.

Browser exports can be imported from Markdown files, ZIP archives, or directories:

contextvault import ./chatgpt-export.md
contextvault import ./contextvault-export.zip
contextvault import ./browser-exports/

The importer reads Markdown entries in memory, validates ContextVault frontmatter, sanitizes filenames, prevents unsafe archive extraction, applies deterministic duplicate detection, and enforces safety limits.

Current limits:

100 MB per archive
10 MB per Markdown file
1,000 files per import ZIP entries are processed in memory rather than extracted to arbitrary disk paths. If the same export is imported twice, the duplicate is skipped. If an updated export shares the same conversation_id, the existing source is updated rather than duplicated.

Normalizing Different Context Sources

Browser chats and terminal sessions do not begin with the same structure. The normalization layer maps both into two shared models: ContextSession and ContextEvent.

Browser messages are mapped as user and agent events, with platform and role metadata preserved. Terminal events retain their explicit types: user, agent, decision, task, problem, and note.

The normalizer also supports legacy snake_case metadata fields — started_at, ended_at, git_branch — alongside current camelCase fields. This keeps existing Markdown sessions readable without requiring a destructive migration.

Building the Local Index

After importing or recording context, rebuild the index with:

contextvault index

The engine reads terminal sessions and imported browser conversations, normalizes them, and writes a local JSON index to .contextvault/index/context-index.json.

Markdown remains the source of truth. The JSON index is derived data. If it becomes corrupted or outdated, delete it and rebuild from the original Markdown files:

Local Markdown
    ↓
Normalize
    ↓
Rebuildable JSON index

There is no proprietary database format and no dependency on a hosted service. Users can inspect, edit, archive, or process their context without ContextVault.

Retrieving Evidence Across Capture Surfaces

Once indexed, context can be queried across both surfaces:

contextvault history --since 2w
contextvault decisions auth --source codex
contextvault problems redis --since 30d
contextvault retrieve "auth middleware" --type decision,task

Supported filters: --type, --source, --since, --limit.

Retrieval is local and deterministic. Ranking considers phrase matches, token matches, event-type boosts, and recency. It does not use embeddings, vector databases, semantic search, external models, or hidden AI calls.

The engine answers: What have I captured about this topic?

It does not claim to answer: What does all my project data mean?

The first question is grounded and testable. The second requires a semantic retrieval layer that ContextVault does not currently include.

Preparing Context for the Next Agent

The prepare command creates a focused context package:

contextvault prepare "auth middleware"

The generated file is written to .contextvault/exports/prepared-context.md. It can include project memory, relevant sessions, decisions, tasks, problems, and source metadata — portable Markdown that can be handed directly to Codex, Claude Code, Cursor, or another AI tool.

ContextVault does not call those tools. It prepares grounded context for the user to move explicitly.

Architecture Overview

The architecture separates four responsibilities:

Capture preserves browser or terminal context
Normalization converts sources into shared records
Indexing and retrieval make those records searchable
Preparation produces portable context for another agent This separation creates boundaries for future adapters without changing the core storage model.

Integrations are adapters. The engine is the product.

Why Markdown Remains the Source of Truth

Project context should remain usable without the application that created it. A proprietary database can be fast, but it also creates dependency and obscures the raw material.

Markdown provides different guarantees: it opens in any editor, works with standard search tools, can be archived directly, remains readable if ContextVault disappears, and can be transformed with scripts or moved between tools.

The JSON index exists for retrieval performance. It is disposable. The Markdown is not.

Git tracks code history. ContextVault preserves the discussions, failed attempts, decisions, and discoveries surrounding that code.

Privacy by Design

ContextVault follows a local-first model. No captured data is sent to a ContextVault backend because there is no backend.

No backend — data remains on the local machine
No accounts — users control their own context
No telemetry — no usage tracking of any kind
No external AI calls — terminal capture and retrieval work entirely locally
No automatic cloud sync — files stay where you put them
No hidden model calls — retrieval stays deterministic The .contextvault/ directory is ignored by Git by default. This matters because raw sessions may contain prompts, local paths, environment details, logs, debugging output, and potential secrets. Automatically committing that material would be an irresponsible default.

Users can choose how to archive or back up their files. ContextVault does not make that choice for them.

What ContextVault Does Not Do Yet

A useful technical project should make its boundaries as visible as its features.

No automatic terminal-agent interception. Vault Terminal captures what the user explicitly records. It does not hook into every shell process or capture complete Codex, Claude Code, or Cursor sessions.

No semantic search. Retrieval is lexical and deterministic. Optional local semantic indexing is future work.

No built-in natural-language answers. ContextVault retrieves evidence and prepares context packages. It does not synthesize answers. Users provide the prepared Markdown to the model they choose.

No automatic IndexedDB synchronization. Browser conversations enter the Context Engine through explicit Markdown or ZIP export and import. The extension does not automatically synchronize with .contextvault/.

Browser adapters can change. LLM providers regularly modify their interfaces. Provider changes may require adapter updates, and the generic adapter remains best-effort.

These are not hidden limitations. They are the honest boundaries of ContextVault 1.3.

Who ContextVault Is For

ContextVault is useful when:

You switch between ChatGPT, Codex, Claude Code, Cursor, or other tools
Coding-agent context windows reset during ongoing work
You need to revisit what an agent attempted several days ago
You want a searchable record of project decisions and problems
You need portable context packages that can move explicitly between tools
You want local ownership without accounts or telemetry It is especially relevant for developers whose AI workflow has grown larger than any single conversation.

Why Not Just Use a Notes App?

Notes applications are useful for polished summaries. They are less effective at preserving raw working context: the failed attempt before the fix, the partial command output that revealed the bug, the agent response that influenced a decision, the unresolved problem discovered during another task, the reason an architectural approach was rejected.

ContextVault preserves that intermediate state. An /agent event records what the agent said — not what you later remember. A /decision event captures an explicit project decision. A /problem event keeps an unresolved issue available for future retrieval.

ContextVault is not a replacement for documentation. It is the context layer that makes future documentation easier to produce because the underlying evidence remains searchable.

Roadmap

The Unified Context Engine now exists. The next phase is reducing manual handoffs and improving retrieval without weakening the local-first model.

MCP Server — Expose project context through the Model Context Protocol so compatible agents can query it through an explicit integration.

VS Code Extension — Surface project decisions, tasks, problems, and related sessions directly inside the editor.

Agent Integrations — Build adapters for Codex, Claude Code, Cursor, and similar tools that can emit the shared context structure automatically.

Optional Local Semantic Indexing — Improve ranking with optional local embeddings while preserving the existing deterministic retrieval path.

Encrypted Backups and Optional Self-Hosted Sync — Support off-machine durability without requiring a third-party hosted service.

These are roadmap items, not implemented features. The current architecture provides the shared models, normalization layer, index schema, and adapter boundaries needed to build them incrementally.

Try ContextVault

ContextVault is fully open source and available today under the MIT License.

Initialize Vault Terminal directly from npm:

npx @aliabdm/contextvault init

Or install it globally:

npm install -g @aliabdm/contextvault
contextvault init

Start recording:

contextvault record

Build and query the local context index:

contextvault index
contextvault history --since 2w
contextvault retrieve "auth middleware"

Capture browser conversations, record coding-agent sessions, build a local context index, and prepare grounded context packages — all while keeping your data on your own machine.

Project links:

GitHub
npm Package
Live Demo
Technical FAQ If you try ContextVault, I'd genuinely appreciate technical feedback. Does retrieval surface the context you expected? Is there a command or workflow you think is missing? How would you improve the developer experience?

Feel free to open an issue, submit a pull request, or connect with me on LinkedIn.

About the Author

Mohammad Ali Abdul Wahed is a Senior Software Engineer specializing in backend systems, Laravel, distributed applications, and AI developer tooling. He is the creator of ContextVault, an open-source local-first context platform that combines a Chrome Extension and an npm CLI to preserve browser conversations, coding-agent sessions, project decisions, and developer workflows across AI tools.

GitHub · LinkedIn · Portfolio

Your AI Chats Are Locked in Corporate Silos. I Built an Open-Source Vault to Rescue Them

Mohammad Ali Abdul Wahed — Tue, 26 May 2026 18:47:10 +0000

I Kept Losing Context Switching Between AI Tools — So I Built a Browser Extension That Remembers Everything

Your AI conversations should not be trapped inside platforms.

The Problem

By 2025, most developers use multiple AI tools every day.

ChatGPT for quick questions
Claude for long reasoning
Gemini for research
Perplexity for analysis

But every platform stores conversations separately.

That creates a frustrating workflow:

Conversations get cut when context windows fill up
Switching platforms destroys continuity
Exporting chats is painful or incomplete
Your history is tied to accounts you don’t control
There’s no unified search across platforms

In short:

The knowledge you build with AI is trapped inside isolated silos.

Why Existing Solutions Didn’t Feel Right

Some tools try solving this problem, but they usually require:

Paid APIs
Backend servers
Account linking
Cloud syncing
Monthly subscriptions

I wanted something simpler.

A question kept bothering me:

What if every AI conversation stayed entirely inside the browser?

No backend. No accounts. No tracking.

The Solution: ContextVault

ContextVault is an open-source Chrome extension that captures AI conversations locally while you use platforms like:

ChatGPT
Claude
Gemini
Perplexity
Poe
DeepSeek
Grok
Microsoft Copilot

Everything stays on your machine.

No telemetry. No external storage.

How It Works

Capturing AI conversations reliably turned out to be harder than expected.

There were two major problems:

1. Every platform has a different DOM structure

Selectors, layouts, and rendering logic differ completely between ChatGPT, Claude, Gemini, and others.

2. AI responses stream in real time

Messages arrive token-by-token instead of all at once.

To solve this, ContextVault uses a 6-layer architecture:

Adapters → Capture → Stream Assembler → Background Worker → Storage → Export

1. Adapters Layer

Each platform has its own adapter implementing a shared interface:

interface LLMAdapter {
  platform: Platform
  urlPattern: RegExp
  messageContainer: string
  userSelector: string
  assistantSelector: string
}

Each adapter knows how to:

Detect the platform
Locate messages
Handle UI differences

2. Capture Layer (DOM + Network)

This is the core system.

DOM Observer

A MutationObserver watches the conversation UI in real time.

It detects:

New messages
Streaming updates
Edited content

Network Monitor

The extension also patches:

fetch
XMLHttpRequest
WebSocket

This provides early access to streaming responses directly from network traffic.

Why both?

DOM reflects exactly what the user sees
Network capture improves streaming accuracy

Using both together dramatically reduced missed messages.

3. Stream Assembler

AI responses arrive in chunks like:

"Hel"
"lo "
"world"

The Stream Assembler rebuilds complete messages while handling:

Chunk merging
Duplicate removal
Completion detection

4. Background Worker

The background worker manages:

Active sessions
Conversation lifecycle
Deduplication
Streaming updates
Conversation linking

It also prevents duplicate saves during rapid streaming events.

5. Storage Layer (IndexedDB)

Everything is stored locally using IndexedDB.

Stored data includes:

Conversations
Drafts
Settings
Projects

Each conversation stores:

Platform
Messages
Timestamps
Model information
Tags
Conversation chains

No external database is used.

6. Export Layer

Conversations can be exported as:

Markdown
ZIP archives

Example output:

## User
How do I design a secure API?

## Assistant
Start with authentication, validation, and rate limiting...

Privacy First

ContextVault was designed around one principle:

Your conversations belong to you.

So the extension:

Has no backend server
Uses no analytics or telemetry
Works fully offline
Only activates on supported AI domains
Never sends your conversations anywhere

Tech Stack

TypeScript
Manifest V3
CRXJS + Vite
IndexedDB
MutationObserver
JSZip
Vitest

Final Thoughts

AI tools are becoming part of how we think, not just how we code.

But memory between tools is still broken.

Every platform acts like a closed silo where conversations disappear the moment you switch workflows.

ContextVault is my attempt to fix that.

A lightweight browser extension that keeps your AI conversations portable, searchable, and fully yours.

Links

GitHub: https://github.com/aliabdm/ContextVault

Demo: https://context-vault-two.vercel.app/

Portfolio: https://senior-mohammad-ali.vercel.app/

LinkedIn: https://www.linkedin.com/in/mohammad-ali-abdul-wahed-1533b9171/

Building with Gemma 4: What I Learned From Turning Job Posts into AI Decisions

Mohammad Ali Abdul Wahed — Fri, 08 May 2026 20:03:55 +0000

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

Building with Gemma 4: What I Learned From Turning Job Posts into AI Decisions

I didn’t start this project to “explore AI”.

I started it because job posts are messy.

Some are vague. Some are misleading. Some look real but feel off once you read them twice.

So I built something simple:

A tool that tells you what a job post actually means.

The idea

Ghost Job Detector takes a job description and returns:

Is this a real job?
Is it a ghost job?
Is it a scam?
Or just a suspicious listing?

But more importantly, it explains why.

Why Gemma 4

I used Gemma 4 because I needed something that can:

understand messy human-written job posts
detect weak signals (not just keywords)
reason about intent
return structured output reliably

I ran it through OpenRouter using:

Gemma 4 26B MoE (primary)
Gemma 4 31B Dense (fallback)

How people can actually use Gemma 4

One thing that surprised me while working with Gemma 4 is how accessible it actually is.

There are a few practical ways to use it depending on your setup:

1. OpenRouter (fastest way to start)

This is what I used in this project.

You can access Gemma models directly through OpenRouter:

no infrastructure setup
no local GPU needed
just API calls

It’s the easiest way to integrate Gemma 4 into a real application.

2. Google AI Studio

Google also provides access through AI Studio.

You can:

test prompts directly in the browser
experiment with models
generate API keys for integration

It’s more of a playground for prototyping than production.

3. Running locally (fully free option)

Gemma models are also open enough to run locally depending on size.

Typical setup:

Download model from Hugging Face or Kaggle
Run using tools like:
- Ollama
- LM Studio
- Transformers (Python)

This gives you:

full control
no API limits
no cost per request

But requires more setup and compute power.

Why this matters

What I realized is that Gemma 4 isn’t tied to a single platform.

You can:

prototype fast with OpenRouter
experiment with Google AI Studio
or run fully offline locally

That flexibility is what makes it practical for real-world projects.

What actually matters in real usage

One thing I learned quickly:

The model is not the hard part.

The hard part is making it behave consistently inside a product.

That meant:

forcing JSON structure
validating outputs
handling API failures
retry logic for rate limits
fallback between models

Real example

Here’s how the system behaves:

Input:

"We are looking for a self-starter in a fast-paced environment."

Output:

Verdict: Suspicious
Reasoning: vague expectations + pressure signals
HR translation: high workload, unclear structure, limited support

HR language is the real problem

A lot of job descriptions don’t lie directly.

They just hide meaning behind corporate phrases.

So I added a “translation layer”:

“Fast-paced environment” → high pressure, overtime likely
“Wear many hats” → multiple roles, single salary
“Self-starter required” → little onboarding or guidance

This part turned out to be more useful than the classification itself.

The biggest engineering lesson

The most important thing I learned:

LLM behavior is mostly a product of constraints, not just model size.

Gemma 4 became much more reliable when I:

strictly defined output schema
reduced ambiguity in prompts
enforced structure in responses

Reliability matters more than intelligence

Since I used free-tier API access, rate limits happened frequently.

Instead of treating that as a blocker, I added:

retry logic
fallback between Gemma models
graceful UI handling when AI is busy

The result: the app never feels “broken”, even when the API is.

Why I built this

Not to replace recruiters.

Not to automate hiring.

But to help people avoid wasting time on job posts that don’t make sense.

Final thought

Building with Gemma 4 felt less like “using AI”

and more like:

designing how AI should behave inside a real product.

That shift is what made this project interesting for me.

Demo

https://ghost-job-detector-rlcx.vercel.app/

Code

https://github.com/aliabdm/Ghost-Job-Detector

Ghost Job Detector: An AI Tool Built With Gemma 4 to Decode Suspicious Job Posts

Mohammad Ali Abdul Wahed — Fri, 08 May 2026 18:55:49 +0000

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

What I Built
I built Ghost Job Detector, a simple web app that helps job seekers analyze suspicious job postings before they apply.

The idea came from a real frustration: many job posts look legitimate at first glance, but they can be vague, recycled, misleading, or even scams. Job seekers often spend time tailoring resumes and applying before realizing the opportunity may not be real.

Ghost Job Detector lets a user paste any job description and get a structured AI report that classifies the post as:

Legit job
Ghost job
Scam
Suspicious job posting
The app also explains why it reached that verdict, highlights red flags, translates coded HR language into plain English, and recommends who should or should not apply.

For example:

"Fast-paced environment" becomes "Expect pressure, shifting priorities, and possible overtime."
"Wear many hats" becomes "You may be covering multiple roles without matching compensation."
"Self-starter" becomes "There may be little onboarding, structure, or management support."
The goal is not to replace human judgment. The goal is to give job seekers a fast, practical second opinion before they share personal information or invest time in a questionable listing.

Demo
Live demo:

https://ghost-job-detector-rlcx.vercel.app/

The app flow is simple:

Paste a job description.
Click Analyze Job.
Review the verdict, confidence score, red flags, HR translation, and candidate-fit advice.
Key sections in the result:

Verdict: legit, ghost job, scam, or suspicious
Risk Signals: red flags and reasoning
HR Reality Translator: corporate phrases decoded into real meaning
Who Should Apply: inferred seniority, recommended roles, apply-if guidance, and do-not-apply-if guidance
Code
GitHub repository:

https://github.com/aliabdm/Ghost-Job-Detector

Tech stack:

Next.js App Router
TypeScript
Vanilla CSS
OpenRouter API
Gemma 4 models
Vercel deployment
Vercel Analytics
Optional Docker setup for local development
How I Used Gemma 4
Gemma 4 is the reasoning engine at the center of this project.

I used:

google/gemma-4-26b-a4b-it:free as the primary model
google/gemma-4-31b-it:free as the fallback model
I chose the 26B MoE Gemma 4 model as the primary model because this project needs more than basic classification. The model has to read a messy job description, reason about intent, identify weak hiring signals, decode HR language, and return a consistent structured JSON response.

The app asks Gemma 4 to return this normalized structure:

{
"verdict": "legit | ghost_job | scam | suspicious",
"confidence": 0.8,
"reasons": [],
"red_flags": [],
"summary": "",
"advice": "",
"hr_translation": [
{
"original": "",
"meaning": ""
}
],
"who_should_apply": {
"recommended_roles": [],
"skill_level": "",
"apply_if": [],
"do_not_apply_if": []
}
}
Gemma 4 powers these parts of the product:

Detecting ghost-job and scam signals
Classifying the post with a clear verdict
Explaining the reasoning in plain language
Translating vague HR phrases into practical meaning
Inferring the real seniority level behind the role
Recommending who should apply and who should avoid the post
I also added resilience around the model calls. If the primary Gemma 4 model is rate-limited or temporarily unavailable, the API silently retries once and then falls back to the Gemma 4 31B Dense model. If all Gemma 4 options are busy, the user gets a clean message instead of a broken UI.

That model choice was intentional: the 26B MoE model gives the app strong practical reasoning for user-facing analysis, while the 31B Dense model provides a stronger fallback path while keeping the whole project inside the Gemma 4 ecosystem.

What I Learned
The most interesting part of this build was designing the prompt and response handling.

A useful AI app needs more than a clever prompt. It needs:

A strict schema
Defensive JSON parsing
Fallback behavior
Clear UX when the model is busy
A result format that normal users can understand quickly
Gemma 4 was especially useful because the task depends on nuance. A suspicious job post is rarely suspicious because of one keyword. It is usually a combination of vague language, missing details, unrealistic requirements, odd application instructions, and implied working conditions.

That made this a good fit for a reasoning model instead of a simple rules engine.

Final Thoughts
Ghost Job Detector is a small project, but it solves a real problem: helping job seekers protect their time, attention, and personal information.

The job market is noisy. Gemma 4 made it possible to turn unstructured job descriptions into clear, actionable guidance.

https://dev.to/maliano63717738

I'm a Recruitment Professional, and This Is Best Way To Get A 100% Safe And High Payin Remote Job Now A day

Mohammad Ali Abdul Wahed — Fri, 08 May 2026 16:46:48 +0000

Years in hiring taught me what wastes job seekers' time and what doesn't. micro1 doesn't. Here's an honest breakdown of how it works and why it matters for anyone struggling to find remote work.
tags: career, remote, jobs, ai
cover_image: https://images.unsplash.com/photo-1486312338219-ce68d2c6f44d?w=1200
The Jobs Are Right Here — Start If You're Ready
👉 [micro1 Open Roles — Remote, All Fields]
https://refer.micro1.ai/referral/jobs?referralCode=f8ce80b3-c190-4f22-815c-dee4a6457153&utm_source=referral&utm_medium=share&utm_campaign=job_referral
Disclosure: I earn a referral reward if you get hired and complete 10+ hours of work. What follows is my honest professional opinion — I only recommend things I'd stand behind.

Why I'm Writing This
I work in recruitment. I've spent years watching talented people — motivated, skilled, willing to work — get chewed up by a hiring system that's inefficient by design.
The problem I see most often, especially with younger professionals looking for remote opportunities, isn't a lack of talent. It's a lack of access and visibility. They don't know which platforms are worth their time. They apply to five job boards, hear nothing back for weeks, lose confidence, and repeat the cycle.
I share resources when I find something that genuinely helps. micro1 is one of those resources.

What Is micro1?
micro1 is a Silicon Valley talent marketplace connecting global professionals with remote roles at AI companies and enterprises.
Fields covered:

Software engineering & QA
Finance & data analysis
Healthcare & legal
AI training, annotation & review
Audio, content & creative

What immediately stood out: every listing includes the salary upfront. No vague "competitive pay." For anyone who's spent time negotiating blind, that's not a small thing.

The Process — And Why It Actually Saves Time
Most job platforms waste months of your life. Apply → silence → maybe a screen call in three weeks → more silence → repeat.
micro1 compresses the whole cycle into ~48 hours.

Browse Jobs ↓ Apply + Upload Resume ↓ Skills Assessment (timed, domain-specific) ↓ AI Interview with Zara ↓ Human Recruiter Review ↓ Offer in Your Inbox

The Zara Interview

Zara is their AI recruiting agent. You do a structured video interview with it instead of waiting for a human calendar slot.
As someone who understands recruiting from the inside, here's what I think they got right:

Practice session first — identical format, zero stakes, just to understand how it works
Domain-specific questions — they're testing real knowledge, not generic HR questions
Consistent and location-neutral — same process whether you're in New York or Amman

Pass Zara → human review → offer email with clear next steps if there's a fit.
Payments for contractors: biweekly via Deel, PayPal, or bank transfer.

A Word for Young Professionals Searching for Remote Work
If you're skilled, motivated, and spending your evenings scrolling through job boards that go nowhere — I want you to read this part carefully.
Remote work has opened up real opportunities across the world. But most platforms still favor people in the right networks and the right cities. The infrastructure to actually access those opportunities hasn't kept pace.
micro1 doesn't ask where you're from. It evaluates you on your skills through a standardized, structured process — and gives you an answer in 48 hours. That's what genuine access looks like. I think it's worth your time.

The Honest Caveats
I give people complete information. Here's what to know before applying:
WhatDetails🪪 ID verificationGovernment ID required during onboarding — for contractor verification and fraud prevention. Non-standard but not a red flag.📭 Rejection feedbackLimited — you may not find out why you didn't pass the assessment📄 Contract modelContractors, not traditional FTEs. Great for flexibility, less ideal if you need immediate local employment benefits⏳ Some roles = talent poolA few listings are building a pipeline for upcoming projects. Your profile stays active regardless.

My Take
I recommend micro1 if you're a mid-to-senior professional in tech, finance, healthcare, legal, or AI-adjacent work, looking for flexible remote income through a fair and transparent process.
Go browse the listings. Apply to what fits. You'll have your answer within 48 hours — which is more than most platforms will ever give you.
👉 Browse micro1 Open Roles
https://refer.micro1.ai/referral/jobs?referralCode=f8ce80b3-c190-4f22-815c-dee4a6457153&utm_source=referral&utm_medium=share&utm_campaign=job_referral

Questions about the process or remote job searching in general? Drop them in the comments — happy to help.

I Built an AI Agent Showcase with Laravel AI SDK — Here’s How You Can Do It

Mohammad Ali Abdul Wahed — Fri, 06 Feb 2026 20:41:47 +0000

How Laravel’s new AI SDK makes building production-ready AI features surprisingly simple (with mock mode for instant demos)
Yesterday, Laravel released their official AI SDK. As someone who’s been watching the AI integration space closely, I knew this was going to be a game-changer for PHP developers.
So I did what any excited developer would do at 11 PM: I built a complete showcase application in one night.

The result? A fully functional AI agent with chat, image generation, text-to-speech, and vector search — all working in your browser right now, no API keys required.

🔗 Live Demo: https://laravel-ai-showcase.onrender.com/
💻 GitHub: https://github.com/aliabdm/laravel-ai-showcase

Here’s exactly how I built it, and how you can do the same.

The Problem with AI Integration
Let me be honest: integrating AI into applications has traditionally been a pain. You’re juggling multiple SDKs, managing API credentials, handling streaming responses, dealing with rate limits, and building fallback systems.

Most developers want to experiment with AI features, but the barrier to entry is high. You need API keys, credit cards, and often hours of setup before you can even see your first result.

Laravel’s AI SDK solves this brilliantly.

What We’re Building
A complete AI showcase with:

✨ AI Chat with real-time streaming
🎨 Image Generation
🔊 Text-to-Speech
🔍 Vector Search with embeddings
🎯 Mock Mode — try everything without API keys
🔄 Session-based mode switching for instant demos
Step 1: Project Setup & Installation
Let’s start fresh:

Create new Laravel project

laravel new ai-showcase
cd ai-showcase

Install Laravel AI SDK

composer require laravel/ai

Publish configuration

php artisan vendor:publish --tag=ai-config
The configuration is beautifully simple:

// config/ai.php
return [
'mode' => env('AI_MODE', 'mock'), // 'mock' or 'real'

'providers' => [
    'gemini' => [
        'api_key' => env('GEMINI_API_KEY'),
    ],
    'openai' => [
        'api_key' => env('OPENAI_API_KEY'),
    ],
],

];
Step 2: The Secret Sauce — Mock Provider
Here’s what makes this project special: a Mock Provider that lets anyone try the app instantly.

Become a member
No API keys. No setup. Just immediate results.

// app/Ai/Providers/MockProvider.php
namespace App\Ai\Providers;
class MockProvider
{
public function text(string $prompt): string
{
return "Hello! I'm a mock AI assistant. You asked: {$prompt}";
}

public function streamText(string $prompt): \Generator
{
    $response = $this->text($prompt);
    $words = explode(' ', $response);

    foreach ($words as $word) {
        yield $word . ' ';
        usleep(100000); // 100ms delay for realistic streaming
    }
}

public function image(string $prompt): object
{
    return (object) [
        'url' => 'https://placehold.co/600x400?text=' . urlencode($prompt),
        'prompt' => $prompt,
    ];
}

}
This simple class saves hours of API setup and makes the app instantly demoable.

Step 3: Smart Mode Switching
Users need to switch between Mock and Real modes seamlessly. Here’s how:

// app/Http/Middleware/AiModeMiddleware.php
namespace App\Http\Middleware;
class AiModeMiddleware
{
public function handle($request, $next)
{
if ($request->session()->has('ai_mode')) {
config(['ai.mode' => $request->session()->get('ai_mode')]);
}

    return $next($request);
}

}
And the controller:

// app/Http/Controllers/ModeController.php
class ModeController extends Controller
{
public function switch(Request $request)
{
$request->validate(['mode' => 'required|in:mock,real']);

    $request->session()->put('ai_mode', $request->mode);

    return response()->json([
        'success' => true,
        'mode' => $request->mode,
        'message' => "Switched to {$request->mode} mode"
    ]);
}

}
Users can now toggle modes with a single click. No server restart needed.

Step 4: Building AI Features
Chat Feature
public function chat(Request $request)
{
$request->validate(['message' => 'required|string']);

if (config('ai.mode') === 'mock') {
    $response = $this->mockProvider->text($request->message);
} else {
    $response = \Laravel\Ai\Facades\Ai::text($request->message);
}

return response()->json([
    'response' => (string) $response,
    'mode' => config('ai.mode')
]);

}
Image Generation
public function generateImage(Request $request)
{
$request->validate(['prompt' => 'required|string']);

if (config('ai.mode') === 'mock') {
    $image = $this->mockProvider->image($request->prompt);
} else {
    $image = \Laravel\Ai\Facades\Ai::image($request->prompt)
        ->landscape()
        ->generate();
}

return response()->json(['url' => $image->url]);

}
Text-to-Speech
public function textToSpeech(Request $request)
{
$request->validate(['text' => 'required|string']);

if (config('ai.mode') === 'mock') {
    $audio = $this->mockProvider->audio($request->text);
} else {
    $audio = \Laravel\Ai\Facades\Ai::audio($request->text)
        ->female()
        ->generate();
}

return response()->json(['url' => $audio->url]);

}
Notice the pattern? Every feature checks the mode and gracefully switches between mock and real AI.

Step 5: Real-Time Streaming (The Highlight!)
This is where it gets exciting. Real-time streaming makes AI responses feel instant and modern:

// app/Http/Controllers/StreamingController.php
public function streamWords(Request $request)
{
$request->validate(['prompt' => 'required|string']);

return response()->stream(function () use ($request) {
    $provider = config('ai.mode') === 'mock' 
        ? $this->mockProvider 
        : null;

    if ($provider) {
        foreach ($provider->streamText($request->prompt) as $chunk) {
            echo "data: " . json_encode(['chunk' => $chunk]) . "\n\n";
            ob_flush();
            flush();
        }
    } else {
        $stream = \Laravel\Ai\Facades\Ai::stream($request->prompt);
        foreach ($stream as $chunk) {
            echo "data: " . json_encode(['chunk' => (string) $chunk]) . "\n\n";
            ob_flush();
            flush();
        }
    }

    echo "data: " . json_encode(['done' => true]) . "\n\n";
}, 200, [
    'Content-Type' => 'text/event-stream',
    'Cache-Control' => 'no-cache',
]);

}
Frontend JavaScript to consume the stream:

async function streamResponse(prompt) {
const response = await fetch('/streaming/words', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'X-CSRF-TOKEN': document.querySelector('meta[name="csrf-token"]').content
},
body: JSON.stringify({ prompt })
});

const reader = response.body.getReader();
const decoder = new TextDecoder();
let output = document.getElementById('output');
output.textContent = '';

while (true) {
    const { done, value } = await reader.read();
    if (done) break;

    const chunk = decoder.decode(value);
    const lines = chunk.split('\n');

    lines.forEach(line => {
        if (line.startsWith('data: ')) {
            const data = JSON.parse(line.slice(6));
            if (data.chunk) {
                output.textContent += data.chunk;
            }
        }
    });
}

}
Users see responses appear word-by-word in real-time. The UX improvement is dramatic.

Step 6: Vector Search with Embeddings
For semantic search capabilities:

// Migration
Schema::create('articles', function (Blueprint $table) {
$table->id();
$table->string('title');
$table->text('content');

if ($this->vectorAvailable()) {
    $table->vector('embedding', dimensions: 768)->index();
} else {
    $table->text('embedding')->nullable();
}

$table->timestamps();

});
Search implementation:

public function semanticSearch(Request $request)
{
$request->validate(['query' => 'required|string']);

if (config('ai.mode') === 'mock') {
    return response()->json([
        'results' => [
            ['title' => 'Mock Result', 'content' => 'Related to: ' . $request->query],
        ]
    ]);
}

$results = Article::query()
    ->whereVectorSimilarTo('embedding', $request->query)
    ->limit(10)
    ->get();

return response()->json(['results' => $results]);

}
Step 7: Bulletproof Error Handling
Production apps need graceful degradation:

private function shouldUseMock(): bool
{
return config('ai.mode') === 'mock'
|| !class_exists('Laravel\Ai\Facades\Ai')
|| !$this->hasApiKeys();
}
private function hasApiKeys(): bool
{
return !empty(env('GEMINI_API_KEY'))
|| !empty(env('OPENAI_API_KEY'));
}
// In controllers
try {
if ($this->shouldUseMock()) {
$response = $this->mockProvider->text($prompt);
} else {
$response = \Laravel\Ai\Facades\Ai::text($prompt);
}

return response()->json([
    'success' => true,
    'response' => $response,
    'mode' => $this->shouldUseMock() ? 'mock' : 'real'
]);

} catch (\Exception $e) {
return response()->json([
'success' => false,
'error' => $e->getMessage(),
], 500);
}
The app never breaks. It always falls back gracefully.

Step 8: Testing Everything
// tests/Feature/AiShowcaseTest.php
class AiShowcaseTest extends TestCase
{
/** @test */
public function mock_mode_works_without_api_keys()
{
config(['ai.mode' => 'mock']);

    $response = $this->postJson('/chat/demo', [
        'message' => 'Hello world'
    ]);

    $response->assertStatus(200)
        ->assertJson(['success' => true, 'mode' => 'mock']);
}

/** @test */
public function mode_switching_works_via_session()
{
    $response = $this->postJson('/ai/mode/switch', ['mode' => 'real']);

    $response->assertStatus(200);
    $this->assertEquals('real', session('ai_mode'));
}

}
Run tests:

php artisan test --filter AiShowcaseTest
Key Lessons Learned

Mock Mode is Essential Lets anyone try your app instantly Zero API costs during development Deterministic responses for testing Perfect for demos and documentation
Session-Based Switching is Powerful Users toggle modes without server restart Great for A/B testing Clear visual feedback builds trust
Streaming Transforms UX Users see responses immediately Perceived performance is dramatically better Modern users expect real-time feedback
Graceful Degradation is Non-Negotiable Always have a fallback Never break the user experience Clear error messages help debugging What We Built ✅ Complete AI Showcase with 4 core features ✅ Dual Mode System (Mock/Real) for flexibility ✅ Real-time Streaming with Server-Sent Events ✅ Session-based Switching for instant demos ✅ Comprehensive Testing with full coverage ✅ Production Ready with proper error handling

Try It Yourself
git clone https://github.com/aliabdm/laravel-ai-showcase.git
cd laravel-ai-showcase
composer install
cp .env.example .env
php artisan key:generate
php artisan serve

Visit http://localhost:8000

All features work immediately in Mock Mode!

Live Demo: https://laravel-ai-showcase.onrender.com/
(Note: It’s on Render free tier, so first load may take a minute)

Conclusion
The Laravel AI SDK makes building AI-powered applications incredibly simple. What would have taken days of integration work now takes hours.

By implementing Mock Mode, session-based switching, and real-time streaming, we’ve created a showcase that:

Works instantly for demos
Scales to production
Provides excellent developer experience
Teaches best practices
The key lesson? Always build with both development and production in mind. Mock modes and graceful fallbacks aren’t just nice-to-have — they’re essential for professional AI applications.

What’s Next?
I’m planning follow-up articles on:

Deploying with Docker
Performance optimization techniques
Extending with custom AI tools
Production security considerations
Monitoring and logging AI usage
Want the complete code? Check out the repository and star it if you find it useful!

Questions? Drop them in the comments — I’d love to help you build your own AI showcase!

Built with ❤️ using Laravel AI SDK
GitHub:
Mohammad Ali Abdul Wahed

Firebase vs Supabase: Why I Switched for PostgreSQL and Cheaper Real-time

Mohammad Ali Abdul Wahed — Fri, 16 Jan 2026 14:19:58 +0000

If you’re a developer, you’ve definitely heard of Firebase—Google’s powerhouse Backend-as-a-Service (BaaS). It has been the industry standard for years. However, as projects scale, many developers (myself included) start looking for something more flexible and, frankly, more affordable.

Recently, I hit a wall with a project. I had two non-negotiable requirements: I needed a robust PostgreSQL database without the "cloud tax," and I needed a real-time solution that wouldn't bankrupt me as my user base grew. This led me straight to Supabase.

Here is my honest comparison and the reasons why I believe Supabase is winning the battle for modern developers.

1. The Database: NoSQL vs. The Power of SQL

The biggest shift when moving from Firebase to Supabase is the underlying architecture.

Firebase (Firestore):
It’s a NoSQL document store. While it's great for simple data, it becomes a nightmare when you need complex relations. You often end up "denormalizing" data or doing multiple nested queries that increase your costs.

Supabase (PostgreSQL):
This was the primary reason I made the switch. Supabase gives you a full PostgreSQL instance. For my project, getting a high-performance relational database for free (on the basic tier) was a game-changer. I could use joins, views, and complex filters that are simply impossible or too expensive in Firestore.

2. Real-Time: Better, Faster, and Significantly Cheaper

There is a common misconception that Firebase is the only king of Real-time. In my experience, Supabase Real-time is not only a viable alternative but often a better one.

Why Supabase Real-time impressed me:
The Cost Factor: In Firebase, every real-time listener and every data sync counts as a "document read." If you have 1,000 users watching a list, your bill explodes. In Supabase, you aren't charged per "read" operation. You pay for bandwidth, which is significantly cheaper.

Postgres Changes: Supabase listens to the PostgreSQL Write-Ahead Log (WAL). This means you can subscribe to specific events (INSERT, UPDATE, DELETE) directly on your database tables.

**Broadcast & Presence: **This is where I saved the most. Supabase allows you to send messages between clients (Broadcast) and track who is online (Presence) without writing any data to the database. It’s low-latency and incredibly cost-effective.

JavaScript

// Supabase Real-time is clean and efficient
const channel = supabase .channel('room-1') .on('postgres_changes', { event: 'INSERT', schema: 'public', table: 'messages' }, payload => { console.log('New message received!', payload.new.text) }) .subscribe()

3. Pricing: Escaping the "Success Tax"

We’ve all heard the horror stories of Firebase "Bill Shocks." Firebase’s pay-per-read model means that if your app goes viral, you might wake up to a $5,000 bill.

The Comparison:
Firebase: You pay for every single operation. Read a document? Pay. Write a document? Pay. It’s hard to predict your monthly costs.

Supabase: They offer a generous Free Tier (which includes that free Postgres DB I needed). Their Pro Plan is a flat $25/month, which covers most of what an MVP needs with very predictable overage costs.

My real-world experience: For a medium-sized app with high traffic, I found that Supabase can be 75% to 80% cheaper than Firebase, mainly because I wasn't being penalized for every database fetch.

4. No Vendor Lock-in

One of the most liberating things about Supabase is that it’s Open Source.

Firebase is a closed Google product. If they raise prices or shut down a service (like they have in the past), you are stuck.

Supabase is built on open tools. If you ever decide to leave their cloud platform, you can take your PostgreSQL database and self-host it anywhere. That peace of mind is priceless.

Final Verdict: Which should you choose?
Stick with Firebase if:

You are building a mobile-first app that requires extremely complex offline-syncing out of the box.

You are deeply integrated into the Google Cloud ecosystem.

*Switch to Supabase if:
*
You want PostgreSQL: You need the reliability and power of a relational database.

You need "Cheap" Real-time: You want to scale your real-time features without worrying about "per-operation" costs.

You want predictable billing: You prefer a flat monthly fee over a "guessing game" bill.

My Experience?
I came for the free PostgreSQL, but I stayed for the Real-time performance and the fair pricing. Supabase has proven that you don't have to sacrifice power for price.

Have you tried Supabase yet, or are you still loyal to Firebase? Let’s discuss in the comments!

AI Orchestration: The Microservices Approach to Large Language Models

Mohammad Ali Abdul Wahed — Sat, 03 Jan 2026 13:01:28 +0000

Stop Asking “Which AI is Best?” Start Asking “How Do I Orchestrate Them?”
As engineers building AI systems in 2025, we’re witnessing a fundamental shift in how we approach artificial intelligence integration. The question is no longer “Should I use GPT, Claude, or Gemini?” but rather “How do I orchestrate multiple specialized models to build robust AI systems?”

This article explores why AI orchestration is the future of intelligent systems and how to implement it effectively.

The Monolithic AI Fallacy
Remember when we built monolithic applications? Everything in one massive codebase, tightly coupled, hard to scale, and impossible to maintain. Then microservices revolutionized software architecture by breaking systems into specialized, independent services.

We’re at that exact inflection point with AI systems.

The industry has been caught in a trap: comparing models head-to-head as if one must reign supreme. “GPT-5 beats Claude!” or “Claude is better at coding!” These comparisons miss the point entirely.

The Reality Check
No single model excels at everything. Each Large Language Model (LLM) has been optimized for different tasks, trained on different data, and architected with different trade-offs. Trying to find one “best” model is like trying to find the one “best” database — it doesn’t exist because the answer depends on your use case.

The 2025 AI Landscape: Specialized Models for Specialized Tasks
Let’s break down the current state of leading AI models and their sweet spots:

Claude (Sonnet 4.5 / Opus 4)
Strengths:

Complex code generation: Claude excels at understanding intricate codebases and generating sophisticated solutions
Long-context processing: With context windows up to 200K tokens, it handles extensive documents and conversations
Technical depth: Superior performance on tasks requiring deep technical understanding
Best for:

Software development and code review
Technical documentation analysis
Long-form content creation
Complex reasoning chains
GPT-5 (OpenAI)
Strengths:

Advanced reasoning: Exceptional at multi-step logical reasoning and problem decomposition
Mathematical prowess: Superior performance on mathematical and scientific tasks
Analytical depth: Strong at breaking down complex problems into structured solutions
Best for:

Scientific research and analysis
Mathematical problem-solving
Strategic planning and decision-making
Educational tutoring
Gemini 3 Flash (Google)
Strengths:

Speed: Fastest inference times among major models
Cost-effectiveness: Significantly lower costs per token
Real-time capabilities: Optimized for streaming and interactive applications
Best for:

Customer service chatbots
Real-time translation
High-volume, low-complexity tasks
Mobile and edge applications
Open Source (LLaMA 3, DeepSeek, Mixtral)
Strengths:

Privacy: Complete data control with local deployment
Customization: Fine-tune for specific domains and use cases
Cost control: No per-token fees for self-hosted deployments
Compliance: Meet strict regulatory requirements
Best for:

Healthcare and financial services
Government and defense applications
Proprietary research
Specialized domain adaptation
Introducing AI Orchestration
AI Orchestration is the practice of intelligently routing tasks to the most appropriate model based on the requirements of each specific task. Think of it as a conductor leading an orchestra — each instrument (model) plays its part when needed to create a harmonious result.

The Architecture
User Request
↓
[Request Analyzer]
↓
[Routing Logic]
↓
┌────────┬────────┬────────┬────────┐
│ Claude │ GPT │ Gemini │ Local │
│ │ │ │ Model │
└────────┴────────┴────────┴────────┘
↓
[Response Aggregator]
↓
Final Response

Key Components
Request Classification: Analyze incoming requests to determine:

Complexity level
Domain (code, math, general, etc.)
Latency requirements
Privacy sensitivity
Cost constraints
Intelligent Routing: Direct each request to the optimal model based on:

Model capabilities and benchmarks
Current load and availability
Cost optimization rules
Privacy and compliance requirements
Response Handling: Process model outputs through:

Validation and quality checks
Format standardization
Error handling and fallbacks
Caching for efficiency
Feedback Loop: Continuously improve routing decisions based on:

Response quality metrics
User satisfaction scores
Performance analytics
Cost tracking
Implementation Patterns
Pattern 1: Task-Based Routing
Route based on the nature of the task:

def route_request(task):
if task.type == "code_generation":
return claude_api
elif task.type == "math_problem":
return gpt_api
elif task.type == "quick_query":
return gemini_api
elif task.is_sensitive_data:
return local_model
Pattern 2: Cascading Intelligence
Start with faster/cheaper models, escalate to more powerful ones:

def cascading_request(query):
response = gemini_api.query(query)

if response.confidence < 0.7:
    response = gpt_api.query(query)

if response.confidence < 0.9:
    response = claude_api.query(query)

return response

Pattern 3: Parallel Processing with Consensus
Query multiple models and aggregate results:

async def consensus_query(question):
responses = await asyncio.gather(
claude_api.query(question),
gpt_api.query(question),
gemini_api.query(question)
)

return aggregate_responses(responses)

Pattern 4: Specialized Pipelines
Chain models for complex workflows:

def content_pipeline(raw_data):
# Fast extraction
structured_data = gemini_api.extract(raw_data)

# Deep analysis
insights = gpt_api.analyze(structured_data)

# Technical implementation
code = claude_api.generate_code(insights)

return code

Real-World Use Cases
Case Study 1: Customer Support Platform
Challenge: Handle 10,000+ daily support tickets with varying complexity

Solution:

Gemini Flash: Handle 80% of simple queries (password resets, status checks)
GPT-5: Process 15% of medium complexity issues (troubleshooting, explanations)
Claude Opus: Resolve 5% of complex technical problems (bug analysis, system integration)
Results:

70% cost reduction compared to single-model approach
40% faster average response time
25% improvement in customer satisfaction
Case Study 2: Healthcare AI Assistant
Challenge: Provide medical information while maintaining HIPAA compliance

Solution:

Local LLaMA model: Process all patient data on-premises
Claude: Generate detailed medical documentation
GPT-5: Analyze research papers and clinical guidelines
Gemini: Handle appointment scheduling and basic queries
Results:

Full HIPAA compliance with local data processing
Comprehensive medical knowledge through specialized routing
Scalable system handling 100K+ monthly interactions
Case Study 3: Development Environment
Challenge: Create an AI coding assistant that handles diverse tasks

Solution:

Claude: Primary code generation and review
GPT-5: Explain complex algorithms and architectural decisions
DeepSeek: Fast code completion and suggestions
Gemini: Quick documentation lookups
Results:

60% increase in developer productivity
Better code quality through specialized review
Reduced API costs by 50%
Benchmarking and Evaluation
To build effective AI orchestration, you need reliable benchmarks. Here are the essential resources:

LMSYS Chatbot Arena URL: https://lmarena.ai

The most comprehensive community-driven benchmark, featuring:

Head-to-head model comparisons
Real user evaluations
Category-specific rankings (coding, math, creative writing)
Regular updates with new models

Artificial Analysis URL: https://artificialanalysis.ai

Focuses on practical metrics:

Response speed comparisons
Cost per token analysis
Context window capabilities
Quality-price ratio evaluations

Open LLM Leaderboard URL: https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard

Become a member
Essential for open-source models:

Standardized evaluation metrics
Academic benchmarks (MMLU, HellaSwag, TruthfulQA)
Model size and efficiency data
Fine-tuning information
Key Metrics to Track
When orchestrating models, monitor these metrics:

Task Success Rate: Percentage of successfully completed tasks per model
Latency: Response time from request to completion
Cost Per Task: Total API costs divided by number of requests
Quality Score: User satisfaction or automated quality metrics
Error Rate: Failed requests or low-confidence responses
Token Efficiency: Average tokens used per successful task
Building Your Orchestration Layer
Step 1: Define Your Use Cases
Map out all AI tasks in your application:

What types of requests do you handle?
What are the complexity levels?
What are your latency requirements?
What are your cost constraints?
What are your privacy requirements?
Step 2: Establish Baseline Benchmarks
Test each potential model on your actual workload:

Create a representative test set (100+ examples)
Measure quality, speed, and cost for each model
Identify each model’s strengths and weaknesses
Document decision rules
Step 3: Implement Smart Routing
Start simple, iterate complex:

class AIOrchestrator:
def init(self):
self.models = {
'claude': ClaudeAPI(),
'gpt': OpenAIAPI(),
'gemini': GeminiAPI(),
'local': LocalModel()
}
self.router = RequestRouter()

def process(self, request):
    # Classify request
    classification = self.router.classify(request)

    # Select optimal model
    model_name = self.router.select_model(classification)
    model = self.models[model_name]

    # Execute with fallback
    try:
        response = model.generate(request)
        self.log_metrics(model_name, request, response)
        return response
    except Exception as e:
        return self.fallback_chain(request, [model_name])

Step 4: Monitor and Optimize
Implement comprehensive observability:

Log every request and response
Track costs in real-time
Monitor quality metrics
A/B test routing rules
Continuously refine your decision logic
Common Pitfalls and How to Avoid Them
Pitfall 1: Over-Engineering
Problem: Building overly complex routing logic from day one

Solution: Start with simple rules based on task type, add complexity only when data shows it’s needed

Pitfall 2: Ignoring Costs
Problem: Not tracking per-request costs until the bill arrives

Solution: Implement cost tracking from day one, set budgets per model, use caching aggressively

Pitfall 3: No Fallback Strategy
Problem: Single point of failure when primary model is down or rate-limited

Solution: Always have 2–3 fallback models configured with automatic failover

Pitfall 4: Static Routing Rules
Problem: Set routing rules once and never update them

Solution: Regularly review performance data, update rules based on new benchmarks, adapt to model improvements

Pitfall 5: Neglecting Privacy
Problem: Sending sensitive data to external APIs without proper safeguards

Solution: Classify data sensitivity, use local models for sensitive data, implement proper data anonymization

The Economics of AI Orchestration
Cost Optimization Strategies
Tiered Routing: Use cheaper models for simpler tasks

Gemini Flash: $0.10 per 1M tokens
Claude Sonnet: $3.00 per 1M tokens
Claude Opus: $15.00 per 1M tokens
Caching: Store and reuse responses for common queries

Reduce API calls by 40–60%
Sub-millisecond response times
Minimal infrastructure costs
Batch Processing: Group similar requests for efficiency

10–30% cost reduction through batching
Better resource utilization
Improved throughput
Hybrid Deployment: Mix cloud and local models

Zero marginal cost for local inference
Control over data and privacy
Backup during API outages
ROI Analysis
For a typical application processing 1M requests/month:

Single Model Approach (Claude Opus only):

Cost: ~$15,000/month
Average latency: 3 seconds
Quality: 95%
Orchestrated Approach:

Cost: ~$6,000/month (60% reduction)
Average latency: 1.5 seconds (50% faster)
Quality: 96% (through specialized routing)
Break-even: Immediate positive ROI

Future Trends in AI Orchestration

Automated Model Selection ML models that learn optimal routing decisions:

Reinforcement learning for routing optimization
Automatic A/B testing of model combinations
Adaptive cost-quality trade-offs

Specialized Model Ecosystems More domain-specific models emerging:

Legal-specific models
Medical-specific models
Financial analysis models
Code-only models

Edge AI Orchestration Extending orchestration to edge devices:

On-device models for privacy
Cloud models for complex tasks
Intelligent data sync

Multimodal Orchestration Routing across different modalities:

Text models for language tasks
Vision models for image analysis
Audio models for speech processing
Code models for development
Getting Started Today
Immediate Actions
Audit Your Current AI Usage

What models are you using?
What are your costs?
What are your pain points?
Benchmark Alternatives

Test 2–3 models on your actual workload
Compare quality, speed, and cost
Identify clear winners for specific tasks
Implement Simple Routing

Start with if-else rules
Add logging and metrics
Iterate based on data
Set Up Monitoring

Track costs per model
Measure response quality
Monitor latency
Resources for Learning More
Technical Documentation:

Claude API: https://docs.claude.com
OpenAI API: https://platform.openai.com/docs
Google AI: https://ai.google.dev/docs
Community Resources:

r/LocalLLaMA for open-source models
HuggingFace forums for model discussions
AI engineering blogs and newsletters
Tools and Frameworks:

LangChain for orchestration
LiteLLM for unified APIs
Helicone for observability
Conclusion: The Orchestrated Future
The question “Which AI is best?” is becoming as outdated as “Which database is best?” The answer is always: it depends on your use case.

The future of AI systems is orchestration. Just as modern software architecture embraces microservices, API gateways, and polyglot persistence, modern AI systems must embrace model diversity, intelligent routing, and specialized capabilities.

The engineers who will build the most successful AI products aren’t the ones who pick the “best” model — they’re the ones who know how to orchestrate multiple models into cohesive, efficient, and powerful systems.

Start thinking like an orchestra conductor, not a solo performer.

The baton is in your hands. What will you create?

About Benchmarking Resources
Throughout this article, I’ve referenced three critical benchmarking platforms that should be part of every AI engineer’s toolkit:

LMSYS Chatbot Arena (lmarena.ai): Community-driven, real-world evaluations
Artificial Analysis (artificialanalysis.ai): Cost and performance metrics
Open LLM Leaderboard (huggingface.co): Academic benchmarks and open-source focus
These platforms are continuously updated as new models are released. Make checking them a regular part of your development workflow.

BTLM
Have you implemented AI orchestration in your systems? Share your experiences in the comments below!

I Built a PDF Chat App in Under an Hour Using RAG- Here's How You Can Too

Mohammad Ali Abdul Wahed — Mon, 29 Dec 2025 09:36:33 +0000

🔗 Live Demo:
https://pdf-chat-rag-fx5nczbrwczzpou6qyczmj.streamlit.app/
📦 GitHub Repo:
https://github.com/aliabdm/pdf-chat-rag
🤔 The Idea
Ever wished you could talk to your documents instead of endlessly scrolling through pages?
That’s exactly what I built using Retrieval-Augmented Generation (RAG) and modern GenAI tools.
Upload a PDF → ask questions → get accurate, context-aware answers in seconds.
❌ The Problem
We’ve all been there:

50-page research papers
Long contracts
Dense technical docs
CVs in recruitment workflows

Ctrl + F isn’t enough when you need:

Summaries
Cross-section answers
Simple explanations
Context-aware responses

✅ The Solution: PDF Chat with RAG
I built a web app that lets you:

Upload any PDF
Ask questions in natural language
Get answers grounded only in your document

👉 Try it live:
https://pdf-chat-rag-fx5nczbrwczzpou6qyczmj.streamlit.app/
🧱 Tech Stack (Why Each Tool Matters)
🧩 LangChain — The RAG Backbone
LangChain makes RAG production-ready by handling:

Document chunking
Embeddings
Retrieval + generation orchestration

Pythonfrom langchain_text_splitters import RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(
chunk_size=1000,
chunk_overlap=200
)

chunks = text_splitter.split_text(text)
⚡ Groq — Lightning-Fast LLM Inference
Groq uses custom LPU hardware and delivers:

~2s response time
Models like Llama 3.3 70B
Generous free tier

Pythonfrom langchain_groq import ChatGroq

llm = ChatGroq(
model_name="llama-3.3-70b-versatile",
temperature=0,
groq_api_key=api_key
)
🔍 FAISS — Vector Similarity Search
When your PDF becomes 100+ chunks, FAISS finds the most relevant ones fast.
Pythonfrom langchain_community.vectorstores import FAISS

vector_store = FAISS.from_texts(chunks, embeddings)
🎨 Streamlit — UI in Minutes
Why Streamlit?

No frontend boilerplate
Built-in chat + file upload
Free deployment

Pythonimport streamlit as st

uploaded_file = st.file_uploader("Upload PDF", type=["pdf"])

if question := st.chat_input("Ask a question"):
pass
🧠 HuggingFace Embeddings
We use all-MiniLM-L6-v2:

Fast
High quality
Runs locally
No API cost

Pythonfrom langchain_community.embeddings import HuggingFaceEmbeddings

embeddings = HuggingFaceEmbeddings(
model_name="sentence-transformers/all-MiniLM-L6-v2"
)
🔄 How RAG Works (Simple Breakdown)
Phase 1 — Document Processing

Upload PDF
Extract text
Split into chunks
Generate embeddings
Store in FAISS

Phase 2 — Question Answering

Embed the question
Retrieve top 3 relevant chunks
Build context
Send to LLM
Return grounded answer

Pythondocs = vector_store.similarity_search(question, k=3)

context = "\n\n".join([doc.page_content for doc in docs])

prompt = f"""
Context:
{context}

Question:
{question}

Answer ONLY based on the context above.
"""

answer = llm.invoke(prompt)
🧪 Core RAG Logic (That’s It)
Pythondef answer_question(question, vector_store, llm):
docs = vector_store.similarity_search(question, k=3)
context = "\n\n".join([doc.page_content for doc in docs])

prompt = ChatPromptTemplate.from_template("""
Context: {context}
Question: {question}

Provide a detailed answer based on the context.
""")

chain = prompt | llm | StrOutputParser()
return chain.invoke({"context": context, "question": question})

🧠 Key Design Decisions

Chunk overlap: avoids cutting context
Temperature = 0: deterministic answers
k = 3 chunks: best speed/accuracy balance

⚠️ Challenges & Fixes
PDF Text Extraction
Some PDFs return broken text.
✔️ Added validation + clear error messages.
Context Window Limits
Large docs exceeded limits.
✔️ Limited chunk size + retrieval count.
Answer Quality
Early answers were vague.
✔️ Strong prompt constraints.

📊 Performance
Metric,Value
PDF size,50 pages
Processing time,~15s
Response time,~2s
Chunks,87
Accuracy,⭐ 8.5 / 10

🚀 What’s Next?

Multi-PDF support
Conversation memory
Export chat history
Word / TXT support

🧑‍💻 Run It Locally
Bashgit clone https://github.com/aliabdm/pdf-chat-rag pip install -r requirements.txt streamlit run app.py
Deploy on Streamlit Cloud in one click 🚀
🧠 Lessons Learned

RAG is simpler than it looks
Speed > model size
Prompt engineering matters
Start simple, iterate fast

🔚 Final Thoughts
Modern AI is about orchestration, not reinventing tools.
If this helped you, consider giving the repo a ⭐
🔗 Connect With Me

LinkedIn: https://www.linkedin.com/in/mohammad-ali-abdul-wahed-1533b9171/
GitHub: https://github.com/aliabdm
Dev.to: https://dev.to/maliano63717738

Happy coding 🚀

I Built a Free URL Shortener in 4 Hours Using Ruby on Rails - Here's Why Rails Still Rocks in 2025

Mohammad Ali Abdul Wahed — Sun, 28 Dec 2025 19:12:12 +0000

I Built a Free URL Shortener in 48 Hours Using Ruby on Rails — Here's Why Rails Still Rocks in 2025

The Problem That Started It All

Yesterday, I was working on an article about my Elixir project. I needed to share multiple long URLs in the post, so naturally, I reached for a popular URL shortening service.

Three clicks later, I hit a wall: "You've reached your limit of 3 short links this month."

As a developer, this felt wrong. Why should something as simple as shortening URLs be locked behind paywalls and limits?

So I did what any developer would do: I built my own.

48 hours later, I had a fully functional, free, open-source URL shortener deployed and running.

Why Ruby on Rails?

In 2025, with all the new frameworks and tools out there, why would I choose Rails?

Simple answer: productivity.

Rails is built on the principle of "convention over configuration" — which means less time configuring, more time building. Here's what I got out of the box:

⚡ Speed of Development

rails new url_shortener -d postgresql
rails generate scaffold Link original_url:text short_code:string clicks:integer
rails db:migrate

Three commands. That's it. I had a full CRUD application with:

Database schema
RESTful routes
Controller actions
View templates

🎯 Smart Defaults

Rails made architectural decisions for me, so I could focus on the unique business logic:

class Link < ApplicationRecord
  before_create :generate_short_code

  private

  def generate_short_code
    loop do
      self.short_code = SecureRandom.alphanumeric(6)
      break unless Link.exists?(short_code: short_code)
    end
  end
end

Six lines of code to generate unique short codes. No external libraries needed.

📦 The Ruby Ecosystem

Need QR codes? There's a gem for that:

gem 'rqrcode'

One line in the Gemfile, and suddenly I could generate QR codes for every short link:

RQRCode::QRCode.new(short_url).as_svg

What I Built

The URL shortener includes:

Instant Short Links - Paste a URL, get a short code
Click Analytics - Track how many times each link is clicked
QR Code Generation - Automatic QR codes for every link
No Registration Required - Anyone can use it freely
Clean, Responsive UI - Built with inline CSS (no framework bloat)

The Technical Stack

Backend: Ruby on Rails 8.1
Database: PostgreSQL
QR Codes: rqrcode gem
Deployment: Render (free tier!)
Time to MVP: Less than 48 hours

Why Rails Made This Possible

1. Active Record Is Magic

Rails' ORM (Active Record) turned database operations into elegant Ruby code:

@link = Link.find_by!(short_code: params[:short_code])
@link.increment!(:clicks)
redirect_to @link.original_url

No SQL, no boilerplate — just readable, maintainable code.

2. Database Migrations Are First-Class Citizens

Every schema change is versioned and reversible:

class CreateLinks < ActiveRecord::Migration[8.1]
  def change
    create_table :links do |t|
      t.text :original_url
      t.string :short_code
      t.integer :clicks, default: 0
      t.timestamps
    end
    add_index :links, :short_code, unique: true
  end
end

3. Convention Over Configuration

Rails assumes sensible defaults. Want a redirect route?

get '/:short_code', to: 'links#redirect'

One line. Rails handles the rest.

4. Deployment Is a Breeze

With Render, deploying Rails apps is ridiculously simple:

Connect GitHub repo
Add environment variables
Hit deploy

Rails' convention-based structure means Render knows exactly how to build and run the app.

The Results

Live URL: [Your Deployed URL]
Source Code: [GitHub Repository]

The project is:

✅ 100% free to use
✅ Open source (MIT license)
✅ Deployable in 10 minutes
✅ No registration required
✅ Fully functional with analytics and QR codes

Lessons Learned

1. Rails Still Delivers on Its Promise

After nearly 20 years, Rails remains one of the fastest ways to build web applications. The "Rails way" isn't just convention — it's accumulated wisdom from thousands of production apps.

2. Choose Boring Technology

Rails isn't trendy. It doesn't make headlines at tech conferences. But it works, and it works consistently.

When you need to ship fast, reach for boring, proven technology.

3. Open Source Wins

Instead of paying for limited features, I built exactly what I needed and made it available for everyone. That's the power of open source.

Try It Yourself

The entire project is open source. You can:

Use the live version at [Your Live URL]
Deploy your own in under 10 minutes
Fork and customize to fit your needs
Contribute features via pull requests

Final Thoughts

In 2025, with AI, microservices, and serverless everything competing for our attention, it's easy to overcomplicate things.

Sometimes, the best solution is the simplest one.

Rails gave me superpowers: I went from idea to deployed product in 48 hours, with clean code, zero configuration headaches, and a fully functional app.

That's the Rails magic that keeps me coming back.

What's your experience with Rails? Or what framework do you reach for when you need to ship fast? Let me know in the comments!

Resources

📂 GitHub Repository: https://github.com/aliabdm/url-shortener-rails
🚀 Live Demo: https://url-shortener-rails.onrender.com/links
💼 Connect on LinkedIn:https://www.linkedin.com/in/mohammad-ali-abdul-wahed-1533b9171/
🐙 Follow on GitHub: https://github.com/aliabdm

If you found this helpful, give the project a ⭐ on GitHub!

Built with ❤️ using Ruby on Rails

🚀 PlainAid: Real-Time AI Text Simplifier Built with Elixir & Phoenix LiveView

Mohammad Ali Abdul Wahed — Sat, 27 Dec 2025 13:38:49 +0000

I recently explored Elixir, a trending, high-performance language, and paired it with Phoenix LiveView to build PlainAid 🎯, a privacy-first web app that simplifies complex text instantly.

Why I Chose Elixir & Phoenix LiveView

Elixir: Runs on Erlang VM → handles millions of concurrent connections
Fault-tolerant & scalable → apps stay reliable under load
Phoenix LiveView: Real-time, interactive UI without heavy JavaScript
Elixir + LiveView lets you build real-time web apps quickly, with clean code and high performance.

What PlainAid Does
PlainAid turns complex legal, official, or formal documents into clear, actionable insights:

✅ Simplified Summary
⚠️ Key Actions
⏰ Deadlines
🚨 Risks
✓ Optional Items
All real-time, secure, and privacy-first — no accounts, no data storage.

flowchart TD
User --> LiveView[Phoenix LiveView UI] LiveView --> Simplifier[Text Simplifier Module] Simplifier --> AI[Groq API (Llama 3.3)] AI --> Simplifier Simplifier --> LiveView LiveView --> User

- User inputs text in the web form
- LiveView updates instantly
- Simplifier sends text to AI API
- Returns structured summary & actionable points
- Displayed real-time

Tech Stack

Component	Technology
Language	Elixir 1.19
Framework	Phoenix 1.7 + LiveView
AI Processing	Groq API (Llama 3.3 70B)
HTTP Client	HTTPoison
JSON	Jason
Styling	Tailwind CSS
Deployment	Render.com

Try It Yourself
🔗 Live Demo: https://lnkd.in/dRFc8uMH
📂 GitHub Repo (Open Source — MIT): https://lnkd.in/dPR7YcGC

Why This Matters

Build interactive, real-time apps with minimal front-end code
Scalable & fault-tolerant → handles growth effortlessly
Privacy-first design → perfect for sensitive documents

Ideas for Contribution
Multi-language support (Arabic, Spanish, French)
Browser extension
Export results to PDF/DOCX
Batch processing of documents
Enhanced AI summarization
📢 PlainAid is live & ready for testing!

Give it a try, fork the repo, or contribute. Let’s make reading complex text simple for everyone.