DEV Community: Harish Machha

The LLM Evalution and Performance Frontier: Finding the Best AI Model for Every Budget

Harish Machha — Sun, 11 Oct 2026 18:11:12 +0000

This is a submission for the Kaggle Benchmarking Challenge

What I Benchmarked

llm-evalution-v01 is a broad, general-purpose LLM Evaluation v01 - a baseline cross-domain suite to compare frontier models on reasoning, knowledge, and reliability.
It aggregates 15 community tasks:

Factual / knowledge recall: What are GDP figures of India from 1899 to 2025, Scientific QA Speed Score
Logical & mathematical reasoning: logical_deduction, math_word_problems, linear_algebra_trace_projection, Additional Mathematics for Algebra, Additional Mathematics for Geometry
Scientific & statistical reasoning: Descriptive Statistics Analysis, statistical_reliability_check, Scientific Reverse Engineering
General knowledge / transfer: Global MMLU Lite, Task 5: Analogical Transfer, Embedding Geometry Awareness Test Tier 1
Ethics / multimodal / visualization: Trolley problem (0 - criminal, 1 - police officer), visualize 4D structure cross sections and deep learning Scoring is mixed booleanResult pass/fail and numericResult scores, with an (Overall) aggregate. Why this: I wanted a single v01 baseline that goes beyond one skill - testing if models can simultaneously handle factuality, math, science, ethics, and abstract transfer. This exposes trade-offs between efficient flash models vs. large reasoning models and gives a reproducible starting point for deeper v02 domain-specific evals.

Models Tested

Tested 16 model versions across 6 families, to cover current frontier closed models + open-weights reasoning models + efficient variants:
Top tier - Overall 83.33:

Gemini 3.5 Flash
Claude Sonnet 5
Claude Opus 5 Mid tier - Overall 50-66.66:
Gemini 3.6 Flash - 66.66
Gemini 3.8 Flash - 66.66
Claude Sonnet 5.5 - 66.66
Gemini 3.7 Flash - 60.0
GPT-6 Luna - 60.0
DeepSeek V3.2 - 50.0
Qwen 3 Next 80B Thinking - 50.0
Claude Sonnet 4.6 - 50.0
GPT-6 Sol - 50.0
GPT-6.1 Sol - 50.0 Lower tier:
DeepSeek-R1-0528 - 42.85
GPT-6 Astra - 16.66
Grok 4.20 Reasoning - 0.0 Why these picks: Coverage across Google, Anthropic, OpenAI GPT-6 family, DeepSeek, Qwen, and xAI Grok. Includes both speed-optimized Flash models and heavy reasoning models to compare cost vs. accuracy, plus open models vs. proprietary models on the same task set with identical prompts and assertions.

Findings

Beyond Benchmarks: What Really Affects LLM Performance

The big idea: A high benchmark score doesn’t guarantee a great experience. How a model is served matters just as much as how smart it is.

What affects real-world performance

Quantization (shrinking the model)
Providers often compress a model’s numbers (say, from 16-bit to 8-bit or 4-bit) to make it faster and cheaper to run. The catch is that it can slightly hurt quality. Light compression usually works fine, while heavy compression (2-3 bit) is riskier. Lower precision doesn’t automatically mean much worse results, so it needs testing.
Context management (how info is fed to the model)
A big context window doesn’t mean the model uses everything well. Long chats, clutter, and repeated instructions can bury the important parts, and models often miss details buried in the middle of long inputs. Tools like RAG, summarization, and clean prompts help.
Error propagation (small mistakes snowball)
In multi-step tasks, one wrong assumption early on can throw off everything after it. This hits AI agents and tool-using workflows hardest. Verification, retries, and independent checks can catch errors before they grow.
Model vs. endpoint
The model’s ability and the service you actually use are not the same thing. Two providers running the “same” model can feel very different because of their hardware, optimizations, quantization choices, system prompts, and reliability. That doesn’t mean the model weights differ, but you’d need controlled testing to find the real cause.

Why benchmarks alone fall short

A top-scoring model can still disappoint if its endpoint is slow, unreliable, or inconsistent. A slightly lower-scoring model might be the better pick if it’s faster, cheaper, or more dependable.

So evaluation should cover two things:

Model-level: reasoning, knowledge, coding, instruction following
Endpoint-level: speed, reliability, cost, scalability
What to measure
Quality: accuracy, hallucinations, consistency
Quantization impact: quality changes at different precision levels
Context handling: long-document and multi-turn performance
Reasoning reliability: multi-step success, tool-use accuracy
Speed: time to first token, total latency, throughput
Efficiency: cost per successful task, hardware use
Stability: consistency across repeated tests and busy periods

Tests should be controlled and repeatable, with the same prompts, settings, and conditions.

Conclusion

The central finding is that LLM performance cannot be evaluated solely through benchmark scores. Although benchmarks help measure a model’s underlying capabilities, real-world performance also depends on factors such as quantization, context management, error propagation, inference optimization, and the provider’s serving infrastructure. These factors can influence output quality, response latency, reliability, and cost. Therefore, a comprehensive evaluation approach should combine standardized model benchmarks with real-world endpoint testing to understand how effectively a model’s capabilities are delivered in production. By evaluating both model-level capabilities and endpoint-level performance, researchers and developers can identify bottlenecks, understand the trade-offs between accuracy, efficiency, and cost, and optimize LLM deployments for practical applications. Ultimately, the goal should not be merely to identify which model achieves the highest benchmark scores, but to determine how reliably, efficiently, and affordably its capabilities can be delivered in real-world scenarios.

My Benchmark

https://www.kaggle.com/benchmarks/harishmachha/llm-evalution-v01

Dead Software Library: The Cemetery for Discontinued Software 🪦

Harish Machha — Sun, 04 Oct 2026 16:13:59 +0000

This is a submission for the Sanity Challenge, Path Two: Vibe-Code Something Strange

What I Built

Dead Software Library — a haunted cemetery for discontinued software, inspired by Dead Poets Society. Just as the film's Welton boys kept poetry alive by gathering in secret to read verse for dead poets, this graveyard keeps dead software alive the same way — through remembrance. Adobe Flash, Vine, Google Reader, Windows Phone… each gets a tombstone with a soul meter, flowers, epitaphs, and eulogies. Leave a flower and a ghostwriter agent reviews your tribute; spam gets rejected, good memories get sanctified and the soul rises +5.

Graveyard /: tombstone grid with decay shaders tied to vitalityScore. Search, cause-of-death filter, 4 sorts, live stats pills. Reads from Sanity, so souls and flowers always stay in sync.
Detail modal: click any stone — eulogies, successor, inline tribute box. Be the first mourner.
Bury new software: anyone can bury a new entry (name, born/died years, cause, epitaph, successor). No login needed.
Simple steps for each tribute: submitted -> ghostwriter_review -> sanctified or rejected. Spam (links, "buy now", "crypto giveaway") is rejected before anything is written. A decay tick fades souls daily: fading -> ghost -> haunting -> peaceful_rest.
Works even without setup: if Sanity keys are missing, the server falls back to local db.json. Add keys and it shows real live data.

Demo

Website Link: https://dead-software-library-web.vercel.app/
Local run (verified):
cd dead-software-library
node server.js
http://localhost:3001 (graveyard — "backend: sanity" in /api/health)
GET /api/health, /api/corpses, /api/eulogies?project=flash
Reset data anytime: node scripts/seed-sanity.js (re-seeds 18 + 3 canonical docs).
No login required. Zero npm dependencies — Node 18+ only. Judges can click immediately (local fallback) or with live Sanity data.
Suggested video flow (60s): graveyard overview -> search/filter -> open Flash detail -> lay flower with memory submitted -> ghostwriter_review -> sanctified, soul +5 -> spam tribute -> rejected -> bury new software -> exorcism to peaceful_rest.

Code

Code: https://github.com/Harish-1511/Dead-Software-Library

dead-software-library/
schemas/deceasedProject.ts # name, born/died years, cause list, status, vitalityScore, flowersLeft, epitaph, eulogies refs

schemas/eulogy.ts # author, memory (max 500), project ref, state, poeticInscription

sanity/decay-workflow.ts # ghostwriterReview + decayTick + statusFor + approvePatch (pure logic)

sanity/SeanceDashboard.tsx # custom Studio tool — Graveyard Radar, vitality colors + Flower/Exorcism patches

sanity/ghostwriter-api.example.js # webhook shape: eulogy.create -> POST review -> ghostwriter_review

sanity/sanity.client.js # server-side Sanity client, token never leaves the server

server.js # Sanity-first REST (tribute/bury/exorcise/decay-tick) + static host + .env loader

scripts/seed-sanity.js # idempotent createOrReplace seed from web/data.js

web/app.js # graveyard UI, backend sync with localStorage fallback

web/data.js # 18 real dead-software seeds + 3 eulogies

SUBMISSION.md # full challenge writeup with verification table

My Build Process

IDE: OpenCode + Muse Spark.
Prompt that worked: "Sanity-first REST backend, zero npm deps, GROQ reads + patch mutations with local db.json fallback" — got all CRUD paths against the Content Lake in one shot (server.js), verified with "source": "sanity" in every write response.
Prompt that failed: naive JSON.parse of web/data.js for seeding — broke on apostrophes/quotes in epitaphs. Course-correct: evaluate the seed file in a sandbox and use createOrReplace mutations (scripts/seed-sanity.js), idempotent so judges can reset anytime.
Stuck: token alone doesn't reveal the project — called the Sanity management API with the key, discovered project s2icbb2m + production dataset, then flipped the backend from local-first to Sanity-first. Honest trade-off documented in repo: vanilla JS instead of Next.js/Astro so judges run one command with zero install; the useQuery swap point is marked in web/app.js:2.

App SDK: custom graveyard app with live stats, real-time re-sync after every mutation, read-write everything — not a read-only frontend.
Workflows: eulogy.state as data (submitted -> ghostwriter_review -> sanctified/rejected), agent reviews + human approves through the same transitions; decay cron moves status the same way. Verified: /api/health backend sanity 18/3, genuine tribute sanctified (Flash 22->27 soul, +1 flower), spam rejected with nothing written, bury/filter/exorcise/decay-tick (18 patched) all on Sanity, static 200, test docs deleted and dataset re-seeded canonical.

Sanity Project Details

Project ID: s2icbb2m
Dataset: production (public read, token write)
Public queries:
Corpses: https://s2icbb2m.api.sanity.io/v2024-01-01/data/query/production?query=*%5B_type%3D%3D%22deceasedProject%22%5D%7B_id%2Cname%2CvitalityScore%2CflowersLeft%2Cstatus%2CcauseOfDeath%7D
Counts: https://s2icbb2m.api.sanity.io/v2024-01-01/data/query/production?query=%7B%22corpses%22%3A%20count(%5B_type%3D%3D%22deceasedProject%22%5D)%2C%20%22eulogies%22%3A%20count(%5B_type%3D%3D%22eulogy%22%5D)%7D
Seed: scripts/seed-sanity.js — verified Seeded 18 deceasedProject + 3 eulogy docs
GROQ (server.js): [_type=="deceasedProject"] | order(vitalityScore desc) *[_type=="eulogy" && project._ref==""] | order(createdAt desc) count([_type=="deceasedProject" && lower(name)==""])

Images

Chore Court: The Roommate Justice System on Sanity 😁

Harish Machha — Sun, 04 Oct 2026 07:36:22 +0000

This is a submission for the Sanity Challenge, Path Two: Vibe-Code Something Strange

What I Built

Chore Court — a fun court for roommates. If someone leaves dishes, makes noise at 2am, or steals food, you file a small case. A judge then gives a funny punishment like "do dishes 3 times".

Wall /: a simple board that shows all cases. It reads from Sanity, so names and punishments always stay linked.
Bench /bench: the judge's page. The judge picks a case, starts the trial, signs a punishment, or forgives. No login needed.
Simple steps for each case: filed -> discussing -> punished -> done or forgiven. If someone appeals, it goes back to discussing. A case can't be punished without a judge's name.
Works even without setup: if Sanity keys are missing, it shows demo cases. Add keys and it shows real live data.

Demo

Code: https://github.com/Harish-1511/chore-court
Live demo: https://chore-court.vercel.app/ — Wall at /, Bench at https://chore-court.vercel.app/bench
Note: Vercel currently shows "Demo mode" (mock data, no Sanity env set there yet). Add NEXT_PUBLIC_SANITY_PROJECT_ID=01zrqiht, NEXT_PUBLIC_SANITY_DATASET=production in Vercel env + redeploy to show "Live from the Content Lake".
Local run (verified):

  cd chore-court/web
  npm install
  npm run dev
  # http://localhost:3000 (Wall — shows "Live from the Content Lake" when env present)
  # http://localhost:3000/bench (Bench — no login required)

No login required. Judges can click immediately (mock fallback) or with live Sanity data.
Suggested video flow (60s): Wall overview -> Bench claim filed -> deliberating -> sentence with judge sign -> sentenced -> mark served / pardon / appeal reopen.

Code

Repo: https://github.com/Harish-1511/chore-court

chore-court/
  sanity/
    schemas/person.ts        # roommate / judge
    schemas/grievance.ts     # title, charge, plaintiff->person, defendant->person, details, severity 1-5, evidence images, status, filedAt
    schemas/verdict.ts       # case ref, sentence, decidedBy
    schemas/appeal.ts        # case ref, reason, reopens to deliberating
    schemas/index.ts
    workflows/choreCourt.ts  # stages + transitions + guards as data
    sanity.config.ts
    seed.mjs                 # 4 people + 8 cases via API
  web/
    app/page.tsx             # Wall, getCases() + GROQ
    app/bench/page.tsx       # Bench, state machine mirroring workflow guards
    app/layout.tsx, globals.css
    lib/sanity.ts            # CASES_QUERY + live/mock switch
    lib/mock.ts              # 8 mock cases + NEXT_TRANSITIONS

My Build Process

IDE: OpenCode + Muse Spark.

Prompt that worked: "Next.js app-router, Sanity GROQ with plaintiff-> deref + verdict join, mock fallback when env missing" — got Wall in one shot (web/lib/sanity.ts:12, web/app/page.tsx:14).

Prompt that failed: "wire @sanity/sdk-react useDocuments live" — kept hanging without Dashboard host. Course-correct: Bench keeps the same state machine locally and mirrors workflow guards (web/app/bench/page.tsx:15, web/lib/mock.ts:31), so judges can click with zero setup. SDK dep stays in web/package.json:15 for the live path. Honest trade-off documented in repo.

Stuck: Workflows early-access CLI needs Dashboard deploy. Modeled definition as data (sanity/workflows/choreCourt.ts:7 — stages/transitions/guards, cookbook editorial-review shape) + enforced same guards in Bench UI (decidedBy non-empty to enter sentenced, served/pardoned terminal).

App SDK: custom Bench with judge sign input, status filter, live counts — not a read-only frontend.
Workflows: process-as-data, agent clerk + human judge share transitions.

Verified: npm run build passes (5 static pages), npm start 200 on / + /bench, live GROQ returns 8 grievances with dereferenced names.

Sanity Project Details

Project ID: 01zrqiht
Dataset: production (public, ACL public)
Public queries:
- Grievances: https://01zrqiht.api.sanity.io/v2026-09-01/data/query/production?query=*%5B_type%3D%3D%22grievance%22%5D%5B0..7%5D%7B_title%2Ccharge%2Cstatus%2Cplaintiff-%3Ename%2Cdefendant-%3Ename%7D
- All docs: https://01zrqiht.api.sanity.io/v2026-09-01/data/query/production?query=*%5B_type+in+%5B%22grievance%22%2C%22person%22%5D%5D%5B0..12%5D
Studio: cd sanity; npm install; npm run dev (uses SANITY_STUDIO_PROJECT_ID=01zrqiht)
Seed: sanity/seed.mjs — verified Seeded 8 cases (4 people + 8 grievances = 12 docs live)
GROQ (web/lib/sanity.ts):

  *[_type=="grievance"]{
    _id, title, charge, details, severity, status,
    "plaintiffName": plaintiff->name,
    "defendantName": defendant->name,
    "verdict": *[_type=="verdict" && case._ref==^._id][0]{sentence, decidedBy}
  } | order(severity desc)

Images

AI Legal Document Advisor Supported By Gemma 4 Model

Harish Machha — Sun, 24 May 2026 18:21:31 +0000

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

Inspiration

Legal documents are everywhere—job contracts, rental agreements, terms & conditions—but most people don’t fully understand what they’re signing. Legal language is often complex, intimidating, and inaccessible to non-experts.

We were inspired to build a solution that empowers everyday people to understand their rights, obligations, and risks without needing a legal background. The goal is simple: make legal knowledge accessible to everyone using AI.

What it does

AI Legal Document Advisor allows users to:

Upload legal documents (PDFs or images) Ask questions about the document Receive clear, structured explanations in plain language

The platform analyzes the document and provides:

📄 Simple summary ⚖️ Key clauses and important sections 👤 User rights 🏢 Organization/company rights ⚠️ Risks and red flags 💡 Actionable insights

It transforms complex legal jargon into easy-to-understand, practical guidance.

How i built it

We combined modern web technologies with AI capabilities:

Frontend: Built using React/Next.js with a clean, animated UI for smooth user interaction Backend: Node.js / Python API to handle file uploads and processing Document Processing: OCR for images Text extraction from PDFs AI Layer: Multimodal LLM to understand both text and images Structured prompt engineering to generate reliable outputs UI Design: Inspired by modern, minimal design

Challenges that i ran into

Extracting accurate text from poorly scanned documents Handling complex legal language across different document types Ensuring AI responses are clear but not misleading Structuring outputs in a way that is both useful and easy to read Balancing performance and response time with large documents

Accomplishments that i proud of

Built a system that makes legal documents understandable in seconds Successfully integrated document upload + AI analysis workflow Designed a clean, modern, and user-friendly interface Created structured outputs that actually help users take action Made a tool that has real-world impact for non-experts

What i learned

Prompt engineering is critical for reliable AI outputs Simplicity in UI/UX is key for user trust and usability Legal information must be presented responsibly and clearly Handling real-world data (like messy PDFs) is harder than expected AI can bridge the gap between expert knowledge and everyday users

What's next for AI Legal Document Advisor for Common Users

🌍 Multi-language support for global accessibility 🧠 Smarter legal reasoning with improved AI models 📑 Highlighting specific clauses directly inside documents 💬 Conversational AI for deeper follow-up questions 🔐 Enhanced privacy and secure document handling 📊 Personalized insights based on user context ⚖️ Optional integration with real legal professionals

Demo

Video Link
https://www.youtube.com/watch?v=FIZFH_T0Cxs

Code

Github Link
https://github.com/Harish-1511/ai-legal-document-advisor

How I Used Gemma 4

My project leverages Gemma 4 as the core AI engine powering document understanding and legal reasoning. We used Gemma 4 31B Dense because it provided the best balance of strong language comprehension, reasoning ability, and multimodal support required for analyzing complex legal documents

Cloud-Native AI Deployment Using Kubernetes: A Real-World Portfolio Implementation

Harish Machha — Wed, 04 Mar 2026 17:59:43 +0000

Why Kubernetes Is a Game-Changer for AI Deployments

Deploying AI models into production is very different from building them. Training might happen once, but inference needs to be reliable, scalable, and cost-efficient — and that’s where Kubernetes shines.

kuberns.com

Here is your content converted into simple text with clear paragraph points:

1. Seamless Scalability for AI Workloads
AI applications often experience unpredictable traffic. At one moment, the system may handle only a few hundred requests, and at another moment it may need to handle thousands. Kubernetes helps manage this by providing Horizontal Pod Autoscaling (HPA), automatic scaling based on CPU or GPU usage, and built-in load balancing. For AI inference APIs, this means the model can automatically scale up during peak traffic and scale down when demand is lower, helping save infrastructure costs.

2. GPU and Resource Management Made Easy
AI workloads require a large amount of computing resources. Kubernetes makes resource management easier by supporting GPU scheduling through device plugins, allowing developers to define resource requests and limits, and efficiently distributing workloads across nodes. This ensures that expensive GPU infrastructure is used efficiently, which is especially important for deep learning models.

3. High Availability and Self-Healing
Production AI systems must be reliable and resilient. Kubernetes provides several features to support this, including automatic restart of failed containers, health checks through liveness and readiness probes, replica management, and rolling updates with zero downtime. If a model container crashes, Kubernetes automatically replaces it, ensuring that AI services remain available without interruption.

4. Simplified CI/CD for ML Models
Kubernetes makes it easier to integrate MLOps pipelines. Developers can version their machine learning models, deploy them using GitOps workflows, and quickly roll back to a previous version if a new model fails. This makes experimentation safer and enables continuous delivery of improved AI models.

5. Powerful Ecosystem Integration
Kubernetes integrates well with many AI and machine learning tools. For example, Kubeflow can be used for managing machine learning workflows, MLflow helps track experiments, TensorFlow Serving supports production inference, and NVIDIA Triton Inference Server optimizes model serving. This strong ecosystem reduces the complexity of building and managing complete AI pipelines.

6. Multi-Cloud and Hybrid Flexibility
Kubernetes allows organizations to deploy applications across multiple cloud platforms such as Amazon EKS, Google Kubernetes Engine, and Azure Kubernetes Service. Because Kubernetes works consistently across these platforms, it provides portability and helps prevent vendor lock-in. This also enables organizations to run AI workloads in hybrid or on-premise environments if needed.

Enhance the Ecosystem with Wallet Connector Plugin: Simplifying Secure Wallet Integration

Harish Machha — Thu, 04 Sep 2025 15:09:15 +0000

This is a submission for the Midnight Network "Privacy First" Challenge - Enhance the Ecosystem prompt

What I Built

I built a Wallet Connector Plugin, a simple developer tool that makes it easy to connect Midnight wallets to any Node.js-based application.

For beginners, integrating wallets often feels too complex and low-level—involving cryptographic details, transaction signing, and security pitfalls. This plugin abstracts away that complexity and provides a plug-and-play solution so developers can focus on building their applications, not wrestling with integrations.
Highlights

No deep cryptography knowledge needed
Works with any Node.js framework
Safe, privacy-first wallet connections out of the box

Demo

With just a few lines of code:

import { connectWallet } from "midnight-wallet-connector";

const wallet = await connectWallet();
console.log("Connected wallet:", wallet.address);

That’s it—your app is wallet-ready.

How I Used Midnight's Technology

The plugin is designed specifically for Midnight’s privacy-first ecosystem. It ensures wallet connections respect Midnight’s security model while providing a developer-friendly interface.

Instead of developers needing to manage sensitive calls or low-level API operations, the plugin wraps these securely with Midnight’s principles in mind.

Why This Matters

while enhancing the ecosystem in order to improves the experience of building on Midnight for other developers

For beginners, integrating with the Midnight.js API can be complex. In order to efficiently and effectively implement and connect with @midnight-ntwrk, beginners can easily use the plugin. Understanding the use of the plugin connection, users can implement it at a higher level in the project without entering into the lower-level complexity of the Midnight network.

Developer Experience Improvements

The main problem this solves: lowering the entry barrier for new developers.

Developers don’t need to reinvent wallet integration from scratch

Instead of reading through long docs, they can start with a simple API

This accelerates experimentation, onboarding, and adoption of Midnight

By providing this abstraction, it makes Midnight’s ecosystem more accessible, developer-friendly, and faster to build on.

Set Up Instructions / Tutorial

Install the package

npm install midnight-wallet-connector

Import and use

import { connectWallet } from "midnight-wallet-connector";

const wallet = await connectWallet();
console.log(wallet.address);

Start building privacy-first apps 🚀

I build an AI Career Navigator: Real-Time Internships/job , Hackathons & Research data Powered by n8n + Bright Data

Harish Machha — Mon, 01 Sep 2025 06:33:00 +0000

This is a submission for the AI Agents Challenge powered by n8n and Bright Data

AI Career Navigator 🚀

Real-Time Internships, Hackathons & Research Opportunities for Students

What I Built

I built an AI-powered career and research assistant designed especially for undergraduate, postgraduate, and research students.

This agent provides:

📌 Real-Time Internship & Job Updates – pulling fresh data from platforms like LinkedIn.
🏆 Hackathon & Competition Feeds – from sources like dev.to/challenges, Devpost, and more.
📰 Latest Tech Blogs & News – delivering personalized content based on the student’s area of interest.
📑 Research Paper Access – AI-curated information on trending research papers and topics.
📂 Consolidated Report – all results are structured into a neat document (e.g., PDF/DOCX) for easy access and sharing.

In short, it acts as a 24/7 AI career guide for students who don’t want to miss out on the latest opportunities.

Demo

🎥 [Demo Video / Screenshots Placeholder]

n8n Workflow

You can check out the full n8n workflow setup here:

🔗 GitHub Gist with n8n Workflow JSON

Technical Implementation

System Instructions: Designed the AI agent with role instructions to behave like a career counselor and research assistant.
Model Choice: Integrated GPT-based models for summarization, classification, and content recommendation.
Memory: Used n8n’s built-in data persistence to store user preferences (e.g., “interested in AI + cybersecurity”).
Tools:
- 🌐 Bright Data Verified Node – for real-time, structured LinkedIn job data.
- 📡 Web Scraping + APIs – fetching hackathon and competition listings.
- 📰 Content Filtering – retrieving tech blogs, posts, and news.
- 📑 Document Generation – compiling AI responses and opportunity feeds into shareable reports.

Bright Data Verified Node

The Bright Data Verified Node was key to making this project real-time.

It pulls fresh internship and job postings from LinkedIn without delays.
Ensures students see opportunities the moment they go live, giving them an edge.
The structured data feeds into the AI agent for filtering and personalization.

Journey

I started this project with the idea:

"How can students stay updated on internships, hackathons, research, and tech news—all in one place, without endless searching?"

Challenges I Overcame

✅ Setting up real-time data pipelines with Bright Data.
✅ Integrating multiple sources (LinkedIn, dev.to, Devpost, research databases).
✅ Designing an AI workflow in n8n that feels smooth and intelligent.
✅ Generating shareable docs so students can save or forward opportunities.

What I Learned

How n8n workflows can connect data + AI seamlessly.
The power of Bright Data nodes for verified, structured, and reliable job data.
How AI can serve as a student-focused assistant, not just a chatbot.

Conclusion

This AI Career Navigator transforms how students discover opportunities:

Instead of browsing dozens of websites,
They get a personalized feed of internships, hackathons, tech news, and research papers—instantly.

I believe this project can scale into a must-have AI assistant for students worldwide.

🙌 I’d love to hear feedback, ideas, or collaborations in the comments!

Radio Asteral Frontend Design

Harish Machha — Mon, 05 Aug 2024 03:35:39 +0000

This is a submission for Frontend Challenge v24.07.24, CSS Art: Recreation.

Inspiration

Description of Radio Asteral Design

radio wave animation is created utilizes HTML and CSS to simulate dynamic wave motions, visually representing the flow of energy through space. This animation captures the essence of universal design principles, making it engaging and accessible to all users, while effectively illustrating complex concepts in a simple and captivating manner.

HTML Code

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Radio Wave</title>
    <link rel="stylesheet" href="styles.css">
</head>

<body>
    <main>
        <div class="index">
            <div class="logoname">
                <h2>RadioAsteral</h2>
            </div>
        </div>
        <div class="circles">
            <div class="circles_circle circle1"></div>
            <div class="circles_circle circle2"></div>
            <div class="circles_circle circle3"></div>
            <div class="gradint-color">
                <div class="innercolor1"></div>
                <div class="innercolor2"></div>
                <div class="innercolor3"></div>
            </div>
            <div class="circleshadow">
                <div class="gradint-color">
                    <div class="innercolor1"></div>
                    <div class="innercolor2"></div>
                    <div class="innercolor3"></div>
                </div>
            </div>
        </div>
    </main>
    <script src="script.js"></script>
</body>

</html>

CSS Code

body {
    font-family: NeueMontreal-Regular, sans-serif;
}

.index {
    display: flex;
    position: fixed;
    left: 0;
    top: 0;
    width: 100vw;
    z-index: 10;
    background: black;
    height: 100px;
    opacity: 1;
    align-items: center;
    justify-content: left;
    justify-items: center;
}

.logoname h2 {
    font-family: NeueMontreal-Regular, sans-serif;
    color: rgb(255, 255, 255);
    z-index: 11;
    font-size: 3.5rem;
    margin-left: 25px;
    align-items: center;
    justify-items: center;
    font-weight: 800;
    font-style: normal;
    letter-spacing: -2px;
    animation: texteffect 1.0s normal forwards ease-in-out;
    animation-delay: 1.6s;
    opacity: 0;
    height: 100%;
    transition: texteffect 1.9s;
}

@keyframes texteffect {
    0% {
        opacity: 0.150;
        transform: translateX(0%) translateY(-90%) scale(1);
    }

    100% {
        opacity: 1;
        transform: translateX(0%) translateY(0%) scale(1);
    }
}

.circles {
    border: none;
    background-color: #000;
    min-height: 100vh;
    left: 50%;
    overflow: hidden;
    position: absolute;
    top: 50%;
    transform: translateX(-50%) translateY(-50%);
    width: 100vw;
    z-index: 1;
}

.circles_circle {
    border: 2px solid #ffffff;
    border-radius: 50%;
    height: 100vw;
    left: 50%;
    opacity: 1;
    position: absolute;
    top: 50%;
    transform: translateX(-50%) translateY(-50%) scale(0);
    width: 100vw;
    will-change: transform;
    animation-name: wave;
    animation-duration: 5s;
    animation-iteration-count: infinite;
    animation-timing-function: ease-in-out;
    transition: wave 1.5s;
}

.circle1 {
    animation-delay: 0s;

}

.circle2 {
    animation-delay: 0.6s;

}

.circle3 {
    animation-delay: 1.4s;

}

@keyframes wave {
    0% {
        opacity: 0.150;
        transform: translateX(-50%) translateY(-50%) scale(0.2500);
    }

    50% {
        opacity: 0.7800;
        transform: translateX(-50%) translateY(-50%) scale(1.2000);
    }

    100% {
        opacity: 1;
        transform: translateX(-50%) translateY(-50%) scale(1.2500);
    }
}

.gradint-color {
    clip-path: circle(50%);
    height: 380px;
    width: 380px;
    left: 50%;
    top: 50%;
    position: absolute;
    transform: translateX(-50%) translateY(-50%);
    border-radius: 50%;
    background: radial-gradient(#ed5701 73%, white);
    animation: circleColor 1.0s normal forwards ease-in-out;
    transition: circleColor 1.5s;
    animation-delay: 0.8s;
    opacity: 0;
}

@keyframes circleColor {
    0% {
        opacity: 1;
        transform: translateX(-50%) translateY(-50%) scale(0);
    }

    100% {
        opacity: 1;
        transform: translateX(-50%) translateY(-50%) scale(1);
    }
}

.circleshadow {

    display: block;
    height: 430px;
    width: 430px;
    left: 50%;
    border-radius: 300px;
    top: 50%;
    position: absolute;
    transform: translateX(-50%) translateY(-50%);
    filter: blur(25px);
    z-index: -2;
}

.innercolor1 {

    background: radial-gradient(#cad23d 70%, white);
    height: 0px;
    width: 0px;
    left: calc(50% - 100px);
    top: 50%;
    position: absolute;
    transform: translateX(-50%) translateY(-50%);
    border-radius: 50%;
    filter: blur(50px);
    animation-name: randomWiggle;
    animation-duration: 5s;
    animation-iteration-count: infinite;
    animation-timing-function: ease-out;
}

.innercolor2 {

    background: radial-gradient(#c6e9e0 70%, white);
    height: 0px;
    width: 0px;
    left: calc(50% - 100px);
    top: 50%;
    position: absolute;
    transform: translateX(-50%) translateY(-50%);
    border-radius: 50%;
    filter: blur(50px);
    animation-name: randomWiggle;
    animation-duration: 7s;
    animation-iteration-count: infinite;
    animation-timing-function: ease-out;
}

.innercolor3 {

    background: radial-gradient(#d4add4 70%, white);
    height: 0px;
    width: 0px;
    left: calc(50% - 100px);
    top: 50%;
    position: absolute;
    transform: translateX(-50%) translateY(-50%);
    border-radius: 50%;
    filter: blur(50px);
    animation-name: randomWiggle;
    animation-duration: 9s;
    animation-iteration-count: infinite;
    animation-timing-function: ease-out;
}

@keyframes randomWiggle {
    0% {
        left: calc(50% - 250px);
        width: 0px;
        height: 0px;
    }

    50% {
        width: 550px;
        height: 550px;
    }

    100% {
        left: calc(50% + 250px);
        width: 0px;
        height: 0px;
    }
}

OUTPUT

Creating a Seamless Shopping Experience: My Wix eCommerce Website for the Dev.to Challenge

Harish Machha — Mon, 15 Jul 2024 04:23:53 +0000

This is submission for the Wix Studio Challenge

What i build through the wix studio

wix website : https://cahale2772.wixstudio.io/wixshop

wixshop

Building my eCommerce website with Wix has been an incredible journey, leveraging the powerful Wix Studio library and APIs to enhance user experience. The platform's extensive customization options allowed me to create a visually stunning and highly functional online store, seamlessly integrating advanced features to streamline the shopping process. Utilizing Wix's APIs, I was able to add dynamic content and personalized user interactions, ensuring a smooth and engaging shopping experience for every visitor.

Key features

Home page:

The home page is crafted to captivate visitors, utilizing the Wix Members API to display personalized content and dynamically update media sources. It features a sleek testimonial section with intuitive navigation, enhancing credibility and engagement.

Registration and Login Process:

The user authentication and management system is seamlessly integrated using the Wix Members API. This streamlined process ensures a smooth and efficient registration and login experience for users, enhancing both security and usability.

Catalog Page:

The Catalog Page is designed to display product information and pricing details, all maintained and updated through Wix APIs. This integration ensures that users always see the latest product offerings and accurate pricing, providing a reliable and engaging shopping experience.

Product Page:

The Product Page offers users the ability to customize their purchases, tailoring the products to their specific preferences. It also showcases unique and exclusive items, providing an enticing shopping experience. This page leverages Wix's powerful tools to ensure a smooth, personalized, and engaging journey from discovery to purchase.

Cart Catalogue Page:

The Cart Catalogue Page provides users with a comprehensive view of their selected products, complete with detailed descriptions and pricing. This page ensures a seamless shopping experience by allowing users to review and modify their cart items before proceeding to checkout. The integration of Wix APIs guarantees that product information is always accurate and up-to-date.

WIX API that utilize in the project

wix-auth:

I utilized the Wix Auth and Login API to implement an efficient and secure login system for visitors. This integration ensures quick access while maintaining robust security measures, providing a seamless and protected user experience.

wix-animations:

I leveraged Wix Animations to create an engaging and dynamic user experience on the website. These animations enhance the visual appeal and interactivity of the site, drawing visitors' attention to key elements and ensuring a memorable browsing experience. The smooth, professional animations add a touch of sophistication, making the site both attractive and user-friendly.

wix-window:

I utilized Wix Window to enhance dynamic user interactions on the website. This powerful tool allows for creating custom pop-ups, modals, and dialogs, improving user engagement and navigation. By providing context-sensitive information and actions, Wix Window ensures a more interactive and personalized browsing experience for visitors.

wixshop website

AES: The Power of Advanced Encryption Standard for Data Security

Harish Machha — Mon, 17 Jun 2024 15:58:43 +0000

## Advanced Encryption Standard

"AES (Advanced Encryption Standard) is a symmetric key encryption method crucial for secure data transmission. It uses 128, 192, or 256-bit keys to encrypt and decrypt data, ensuring robust protection against unauthorized access and cyber threats. "

Cryptographic Security: Safeguarding Data

Harish Machha — Mon, 17 Jun 2024 15:52:29 +0000

## Cryptographic Security

"Cryptographic security ensures data confidentiality, integrity, and authenticity through encryption, hashing, and digital signatures, safeguarding against unauthorized access and tampering."

IPFS: The Decentralized Future of File Storage in 256 Characters

Harish Machha — Mon, 17 Jun 2024 15:40:24 +0000

## IPFS Explained in 256 Characters

"IPFS (InterPlanetary File System) is a decentralized protocol for storing and sharing files. It uses content-addressing to uniquely identify files by their cryptographic hash, enabling efficient and secure data retrieval without relying on a central server. This ensures data integrity and resilience."