DEV Community: Raja Karuppasamy

I built a CI/CD intelligence platform that scores every deploy and comments on your PRs

Raja Karuppasamy — Wed, 25 Mar 2026 06:03:18 +0000

The Problem: If you're an engineering manager or dev lead, you've probably asked these questions:

"What shipped while I was sleeping?"
"How risky was that deploy?"
"Why does this pipeline keep failing?"
"How much are we wasting on GitHub Actions?"

I kept hearing these from eng managers. The answers always required digging through GitHub, cross-referencing Slack, and manually reconstructing timelines.
So I built DeployGuard.
What is DeployGuard?
It's a CI/CD intelligence platform with five capabilities:
Deploy Guard — Every push to production gets a risk score from 0–100 based on lines changed, files touched, test results, time of day, and author failure history.
Cost Tracker — Per-repo, per-workflow CI/CD spend visibility. Automatically detects waste like flaky test reruns.
Incident Replay — When a deploy fails, an incident is auto-created with the commit, PR, workflow, and error context.
Intelligence Engine — Automatically detects recurring failure patterns, flaky pipelines, and calculates CI waste in dollars. No rules to configure.
PR Bot — Posts a DeployGuard analysis comment directly on every PR with risk score, duration, and cost. Engineers see it without leaving GitHub.

How the Risk Scoring Works
The scoring engine evaluates 5 factors, each contributing 0–20 points:

Lines changed
Files touched (config files weighted 2x)
Test results
Time of day (Friday 5pm = high risk)
Author's 30-day failure rate

A deploy that changes 500 lines across 30 files on a Friday afternoon with no tests? That's scoring 85+ (danger zone).
A small Monday morning fix with all tests passing? Score: 10 (safe).
The Intelligence Engine
This is what makes DeployGuard different from a dashboard. It actively finds problems:
Recurring Failures — Groups failures by workflow and counts occurrences. "Your deploy-production workflow failed 5 times in 7 days" with the common commit messages that triggered failures.
Flaky Pipeline Detection — Finds workflows where the status alternates between success and failure. Calculates a "flakiness score" based on how often the status flips.
CI Waste Calculation — Sums up the dollar cost of failed builds, flaky reruns, and repeated failures. Shows you exactly how much money your CI pipeline is wasting.
The PR Bot
Every PR gets an automatic comment:
MetricValueRisk Score🟢 20/100 (safe)WorkflowCIDuration33sCI Cost$0.0080
This is the highest-impact feature. Engineers see the analysis without opening another tool.
The Tech Stack

Next.js 16 + TypeScript
Supabase (PostgreSQL + Row Level Security)
GitHub App with webhooks
Stripe (billing)
Vercel (hosting)
Slack Incoming Webhooks

Total monthly cost: $0 (all free tiers).
Try It
DeployGuard is free for 1 repo. No credit card.

Go to deployguard.dev
Connect your GitHub
See your first risk score on the next push

I'm a solo developer building this under ClearFix.co. Would love feedback from anyone managing engineering teams.

How to get AI-powered CI/CD failure diagnosis in 4 lines of GitHub Actions code

Raja Karuppasamy — Mon, 02 Mar 2026 14:42:50 +0000

Every DevOps engineer knows this feeling: your pipeline fails at 2AM,
the error says "Unknown error" and you spend 45 minutes digging through
logs to find the actual cause.

I built PipelineIQ to fix this. Here's how to set it up in 4 lines.

What it does

When your GitHub Actions pipeline fails, PipelineIQ:

Reads the error logs automatically
Sends them to Claude AI for diagnosis
Posts the root cause + fix steps to your Slack
Updates your DORA metrics dashboard

All within seconds of the failure.

The 4-line integration

Add this step to any GitHub Actions workflow:

- name: PipelineIQ
  if: always()
  uses: Raja-Karuppasamy/pipelineiq-action@v1
  with:
    api-key: ${{ secrets.PIPELINEIQ_API_KEY }}
    job-status: ${{ job.status }}

That's it. No configuration. No webhooks to set up. No manual curl commands.

What you get

AI Diagnosis — instead of "exit code 1", you get:

"The deployment is failing because the application cannot establish
a connection to PostgreSQL at db.production.internal:5432. This is
likely due to missing DATABASE_URL in production environment variables."

Recommended Fix — specific numbered steps:

Verify DATABASE_URL is set in Railway/Heroku/Render environment

Check if database is running: pg_isready -h db.production.internal

Verify connection string format: postgresql://user:pass@host:5432/db

DORA Metrics — deployment frequency, change failure rate, MTTR,
and lead time — automatically computed from your pipeline data.

Slack + Email alerts — your team gets notified with the diagnosis
before anyone has opened their laptop.

Getting started

Sign up at pipelineiq.dev/signup — free, no credit card
Add PIPELINEIQ_API_KEY to your GitHub repo secrets
Add the 4-line step to your workflow
Push a commit

Free tier includes 100 pipeline runs/month.

Why I built this

I was tired of spending 30-60 minutes per pipeline failure just
understanding what broke. The logs are always there — they just need
someone (or something) to read them properly.

PipelineIQ uses Claude AI to read your logs the way a senior DevOps
engineer would — with context about what the error actually means and
what to do about it.

Try it free: pipelineiq.dev/signup

Would love feedback from anyone who tries it.

How I built an AI tool that diagnoses CI/CD pipeline failures in seconds

Raja Karuppasamy — Sat, 28 Feb 2026 04:03:04 +0000

Every engineering team I've talked to has the same frustration.
Pipeline fails. Engineer gets a Slack notification. Opens GitHub Actions. Stares at 300 lines of logs. Googles the error. Checks Stack Overflow. 45 minutes later — maybe they've found the fix.
I built PipelineIQ to eliminate that 45 minutes.
What it does
When a CI/CD pipeline fails, PipelineIQ automatically:

Captures the error logs
Sends them to Claude AI for analysis
Delivers a Slack alert with the exact root cause and fix steps — within seconds

Here's a real example of what lands in Slack:
🔴 Pipeline Failure: Stripe API connection timeout blocking payment webhooks

AI Diagnosis: The deployment is failing because the application cannot establish a connection to Stripe's API within the 30-second timeout limit. This is preventing payment webhook processing.
Recommended Fix: Check STRIPE_SECRET_KEY and STRIPE_PUBLISHABLE_KEY in production environment variables. Test connectivity to api.stripe.com from your deployment environment. Increase API timeout from 30s to 60s.

No log diving. No guessing. Specific, actionable steps.
The stack

FastAPI — Python backend with async support
Supabase — PostgreSQL database with Row Level Security
Anthropic Claude API — AI diagnosis engine
Slack API — Rich block-based alerts
Railway — Production deployment
GitHub Actions — Integration via one workflow step

How the integration works
You add one step to any existing GitHub Actions workflow:
yaml- name: Notify PipelineIQ
if: always()
run: |
curl -X POST $PIPELINEIQ_URL/api/v1/pipelines/runs \
-H "X-PipelineIQ-Key: $PIPELINEIQ_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"repo_full_name": "${{ github.repository }}",
"branch": "${{ github.ref_name }}",
"commit_sha": "${{ github.sha }}",
"commit_message": "${{ github.event.head_commit.message }}",
"workflow_name": "${{ github.workflow }}",
"status": "${{ job.status }}",
"started_at": "${{ github.event.head_commit.timestamp }}"
}'
That's it. Every run — success or failure — gets stored. Every failure triggers AI diagnosis automatically.
The AI diagnosis engine
The core of PipelineIQ is a FastAPI background task that fires Claude when a failure is stored:
pythonasync def run_ai_diagnosis(run: dict, org_id: str, supabase: Client):
insight = await diagnose_from_run(run)
if not insight:
return

supabase.table("insights").insert({
    "severity": insight.get("severity"),
    "title": insight.get("title"),
    "diagnosis": insight.get("diagnosis"),
    "recommendation": insight.get("recommendation"),
    "estimated_time_save_minutes": insight.get("estimated_time_save_minutes"),
    "confidence": insight.get("confidence"),
}).execute()

await send_pipeline_alert(insight, run)

Claude returns structured JSON with severity, diagnosis, recommendation, confidence score, and estimated time saved. The whole thing runs in under 5 seconds.
What's next
Right now PipelineIQ stores pipeline runs, generates AI diagnosis on failures, and sends Slack alerts. The roadmap includes:

Web dashboard with pipeline health across all repos
DORA metrics (deployment frequency, change failure rate, recovery time)
Environment drift detection
Industry benchmarks — how does your team compare?

Try it free
PipelineIQ is in free beta. I'm looking for engineering teams to try it and give honest feedback on what's missing.
👉 pipelineiq.dev
API docs: pipelineiq-production-3496.up.railway.app/docs
Happy to answer questions in the comments — especially from DevOps engineers who deal with pipeline failures daily.