DEV Community: prabanjan Sakthibabu

TalentForge AI — Building a Production-Ready Authenticated AI App on Cloud Run

prabanjan Sakthibabu — Mon, 31 Aug 2026 19:26:37 +0000

TalentForge AI — Building a Production-Ready Authenticated AI App on Cloud Run

Submission for #AccelerateAIwithCloudRun — Beyond the Personal Gemini Journal starter

Live Demo (Cloud Run): https://talentforge-ai-xxxx-uc.a.run.app (or see Walkthrough Video below)
Repo: https://github.com/prabanjan127/talentforge-ai
Demo Video: https://youtu.be/XXXX / Blog: You are reading it — publish this to Medium/Dev.to/Hashnode and use that URL for submission
Firestore Rules: firestore.rules:3 — per-user isolation users/{uid}

1. What We Built

TalentForge AI is an authenticated AI Career Coach, not a generic journal. It helps users land jobs faster with 4 Gemini-powered modes, all secured per-user:

Resume Review (ATS) — Match score 0-100, missing keywords, 3-5 bullet rewrites
Cover Letter Generator — 250-word tailored letter from resume + JD
Gap Analysis — 30-60-90 day learning plan with courses/projects
Mock Interview Chat — Strict hiring manager, one question at a time, feedback after each answer

History persists in users/{uid}/applications (Firestore) and is deletable. All Gemini calls are server-side on Cloud Run.

Why beyond starter: Custom AI Studio system instructions per mode (backend/src/services/gemini.js:15), interview chat with history, hardened auth, single Cloud Run service serving Vite React + Express.

2. Architecture

[Vite React 19] -- Firebase Auth (Google SSO) --> [Express 5 on Cloud Run]
   |  Bearer ID Token                           | verifyIdToken (firebase-admin)
   |                                            |--> Gemini 3.6-flash (AI Studio)
   |                                            |--> Firestore users/{uid}/applications
   Dockerfile multi-stage: frontend build -> backend serves dist

Frontend: frontend/ Vite + React Router + Firebase Client SDK + Tailwind 3. frontend/src/firebase.js:5 + frontend/src/contexts/AuthContext.jsx:12 (demo fallback demo-token for keyless preview)
Backend: backend/ Express + firebase-admin/app:cert (backend/src/config/firebase.js:9) + @google/generative-ai. Serves frontend dist, health at /health (backend/src/index.js:19)
Security: helmet, cors, authMiddleware (backend/src/middleware/auth.js:1), Firestore rules deny all except owner, Gemini key never exposed to client (Secret Manager / env var), morgan logging
Stability: Input validation, try/catch on Gemini + Firestore (best-effort in demo), loading states, /api/health

3. Gemini via AI Studio — Custom Instructions

Designed in AI Studio, exported to backend/src/services/gemini.js:15:

resumeReview: FAANG hiring manager + ATS, returns Score, Missing Keywords, Bullet Improvements, Verdict (markdown)
coverLetter: Professional coach, 250-300 words, professional enthusiastic
gapAnalysis: Career strategist, 30-60-90 plan with resources
mockInterview: Strict supportive hiring manager, one Q at a time, feedback loop

Model: gemini-3.6-flash (tested via https://generativelanguage.googleapis.com/v1beta/models?key=... — gemini-1.5-flash deprecated, 2.5 no longer available to new users).

Edit: AI Studio → New Prompt → System Instructions → paste → Test → copy to SYSTEM_INSTRUCTIONS.

4. Walkthrough — Screenshots / Video Script

Record with Loom / OBS, 2-3 min:

0:00 — Show http://localhost:8080 or Cloud Run URL. Demo banner if DEMO_MODE=true (frontend/src/components/Navbar.jsx:8).
0:20 — Login: Click Sign in with Google (frontend/src/pages/Login.jsx:15), Firebase Auth popup, redirect to / (ProtectedRoute frontend/src/components/ProtectedRoute.jsx:1).
0:40 — Profile: Enter Target Role Software Engineer, paste resume + JD. Show prefilled example.
1:00 — Resume Review: Click Resume Review → Gemini thinking → markdown result with Score 78/100, missing keywords React 19, Cloud Run, bullet rewrites. Network tab shows POST /api/ai/resume-review with Authorization: Bearer <ID_TOKEN>.
1:20 — Cover Letter + Gap Analysis: Click each, show generated markdown, then History (Firestore) panel on right updates — proves per-user persistence users/{uid}/applications.
1:40 — Mock Interview: Click Mock Interview tab → send Hi I'm ready → Gemini asks Q1, answer, get feedback + Q2 — show chat history passed to backend/src/routes/ai.js:75 generate(..., history).
2:00 — Firestore Rules: Show firestore.rules + Firebase Console Firestore Data users/demo-user-123/applications — only owner sees it.
2:20 — Cloud Run: Show gcloud run deploy logs or Console → Cloud Run → Service talentforge-ai → URL → curl /health.

Screenshots to include in blog:

Login page with Google SSO
Dashboard with 3 textarea + 4 buttons + History panel
Resume Review output markdown
Mock interview chat
Firestore console with users/{uid} path
Cloud Run service URL + health JSON

5. Local Run

# Firebase setup: console.firebase.google.com → Auth (Google) → Firestore → Web app config
cp frontend/.env.example frontend/.env  # fill VITE_FIREBASE_*
cp backend/.env.example backend/.env    # fill GEMINI_API_KEY, FIREBASE_SERVICE_ACCOUNT, DEMO_MODE=false

cd frontend && npm install && npm run build
cd ../backend && npm install && npm start  # http://localhost:8080
# or dev: npm run dev in both

Test: curl http://localhost:8080/health → {"status":"ok"}

6. Deploy to Cloud Run

Console (no gcloud permission needed):

Enable APIs: console.cloud.google.com/apis/library/firestore.googleapis.com?project=target-13bf5 → Enable (same for run.googleapis.com, cloudbuild.googleapis.com, artifactregistry.googleapis.com)
Firestore → Create database → Production → us-central1
Cloud Run → Create Service → Continuously deploy from source → Connect github.com/prabanjan127/talentforge-ai → Dockerfile → Region us-central1 → Allow unauthenticated → Env vars GEMINI_MODEL=gemini-3.6-flash, FIREBASE_PROJECT_ID=target-13bf5 → Secrets GEMINI_API_KEY, FIREBASE_SERVICE_ACCOUNT (Secret Manager) → Deploy

CLI (after gcloud auth login as owner):

gcloud builds submit --tag gcr.io/target-13bf5/talentforge-ai
gcloud run deploy talentforge-ai --image gcr.io/target-13bf5/talentforge-ai --platform managed --region us-central1 --allow-unauthenticated --port 8080 --set-env-vars GEMINI_MODEL=gemini-3.6-flash,FIREBASE_PROJECT_ID=target-13bf5 --set-secrets GEMINI_API_KEY=gemini-key:latest,FIREBASE_SERVICE_ACCOUNT=firebase-sa:latest
curl https://talentforge-ai-xxxx.run.app/health
firebase deploy --only firestore:rules

7. Security & Evaluation

Authenticity: 4 modes + chat beyond starter
Usability: Google SSO, ProtectedRoute, error-free flows
Stability: Server verifies ID token, handles Gemini 404/403, Firestore disabled fallback, health checks
Security: firestore.rules per-user, API keys server-only, helmet, ID token auth

8. Submission Links

Cloud Run Live URL: https://talentforge-ai-xxxx-uc.a.run.app (replace after deploy)
Social Post: Publish this blog to Medium/Dev.to with #AccelerateAIwithCloudRun + video https://youtu.be/XXXX
Repo: https://github.com/prabanjan127/talentforge-ai

Built by following Codelab “Build a User-Authenticated AI Application with Custom Instructions on Google AI Studio & Cloud Run” then extended with hardened security and unique career features.

AccelerateAIwithCloudRun #Firebase #CloudRun #Gemini #AIStudio

AI Security Log Auditor

prabanjan Sakthibabu — Tue, 25 Aug 2026 18:44:35 +0000

AI Security Log Auditor

Manual log triage takes 15+ minutes and misses stealthy bursts. This dashboard ingests raw Syslog/Nginx/auth.log/Suricata logs, redacts credentials client-side, clusters anomalies with lightweight heuristics, and streams structured threat JSON (threatLevel, attackVector, mitreTechniqueId, confidence, remediation) into an interactive cyber-terminal for instant iptables/fail2ban/nginx mitigations.

Live Demo: https://ai-security-auditor-one.vercel.app · Video: (Unlisted YouTube link) · Blog: (Dev.to/Hashnode link)

Architecture

flowchart LR
  A["Raw Logs<br/>Syslog / Nginx / auth.log"] --> B["Ingestion & Sanitization<br/>redact credentials<br/>cluster anomalies"]
  B --> C["Structured Prompt<br/>threatLevel, attackVector, mitreId"]
  C --> D["AI Inference<br/>Gemini Flash / Ollama"]
  D --> E["Risk & Remediation<br/>Health = 100 - C*25 - W*10"]
  E --> F["Angular Signals<br/>metrics / table / terminal"]
  F --> G["Dark Cyber UI"]

Pipeline highlight file mapping:

src/app/models/security.model.ts:1 — LogEntry, ThreatReport, MitreTechnique, RemediationAction, DashboardMetrics
src/app/services/log-generator.service.ts:32 — getAttackPresets() / getSampleLogsByPreset() / parseRawLogLines()
src/app/services/ai-auditor.service.ts:18 — ingestLogs() → mitreMap (T1110.001, T1190, T1046, T1078) + buildRemediation()
src/app/components/dashboard/dashboard.component.html:20 — metric bar, src/app/components/dashboard/dashboard.component.html:32 drag-drop zone (dragover)/(drop), src/app/components/dashboard/dashboard.component.html:145 remediation terminal

Tech Stack

Layer	Choice	Why
Frontend	Angular 17+ standalone, TypeScript, `CommonModule` + `FormsModule`	Reactive signals/services, strict types
Styling	Bootstrap 5.3 + SCSS (`src/app/app.scss:1`, `src/app/components/dashboard/dashboard.component.scss:1`)	Terminal dark theme `#0a0f1d`, `#1e293b` cards, glowing badges
Icons	Font Awesome 4.7 (`angular.json:36`)	`fa-shield`, `fa-terminal`, `fa-bug`
AI	Gemini 2.0 Flash (cloud) / Ollama Llama 3.1 8B local	Spec schema: `threatLevel`/`attackVector`/`mitreTechniqueId`/`confidenceScore`/`remediationCommands` — fallback heuristic already ships
Build	Angular CLI `ng build` / `ng test` (Vitest)	`angular.json:43` budgets `700kB/14kB`

Recommended models per spec: Gemini 2.0 Flash (1M context, sub-second) for hosted; Ollama (Qwen 2.5 Coder) for air-gapped — logs never leave browser.

Features

Ingestion: drag-drop, browse, 6 presets (Full 49 / SSH 15 / SQLi 8 / Recon 5 / API 1 / Clean 20), paste raw text — all via src/app/components/dashboard/dashboard.component.ts:55 onDragOver/onDrop/handleFile
Sanitization: client-side redaction before any AI call (sanitizedTokensCount in header)
Metrics: Total Ingested / Critical / Warning / Health 100-(C×25+W×10) with conic ring healthColor()
Threat Intel: filterable table (search IP/vector/MITRE, severity & vector dropdown) — selectable row opens inspector with aiAnalysis, MITRE link, IoCs, raw redacted line
Terminal: per-threat iptables/fail2ban/ufw/nginx with Copy, Run (Sim), Copy All, Export .sh (downloadScript()), simulated stdout

Quick Start

# prerequisites: Node 20+, npm 10+
git clone https://github.com/prabanjan127/ai-security-auditor.git
cd ai-security-auditor
npm install          # installs bootstrap@5.3.8 + font-awesome@4.7.0 per angular.json:33
ng serve             # http://localhost:4200 — dashboard auto-loads Full Attack Suite
ng test              # 2/2 passing (src/app/app.spec.ts:1)
npm run build        # → dist/ai-security-auditor/browser/

Try it:

Click Load Sample Attack Logs or any preset pill.
Or drop a .log (e.g. auth.log with Failed password for invalid user admin from 203.0.113.5).
Filter by CRITICAL, search 203.0.113, select a row → copy sudo iptables -A INPUT -s 203.0.113.5 -p tcp --dport 22 -j DROP from terminal.

Deploy

Vercel (recommended)

npm i -g vercel
vercel --prod  # uses vercel.json (output: dist/ai-security-auditor/browser)

vercel.json already contains SPA rewrite /(.*) → /index.html.

Netlify / GitHub Pages

npm run build
# Netlify: drag dist/ai-security-auditor/browser
# GH Pages: npx angular-cli-ghpages --dir=dist/ai-security-auditor/browser

Project Links (replace before submit)

GitHub: https://github.com/prabanjan127/ai-security-auditor
Live Demo: https://ai-security-auditor-one.vercel.app
Blog (Dev.to/Hashnode): paste draft from prompt + screenshots above
Video (Unlisted YouTube): 0:00 problem / 0:30 upload demo / 1:30 architecture

How It Works (for blog/video)

Ingest — drop .log → LogGeneratorService.parseRawLogLines() clusters anomalies.
Sanitize — sanitizeLine() redacts Bearer/api_key before inference.
Infer — structured prompt expects {threatLevel, attackVector, mitreTechniqueId, confidenceScore, remediationCommands}.
Score — calculateDashboardMetrics() → health.
Display — DashboardComponent binds via applyFilters() / selectReport(); terminal streams terminalOutput[].

License

MIT — showcase project; not for production firewall automation without review.