DEV Community: Vernard Sharbney

Security Benchmark Explorer: An AI Agent That Only Works Because the Content Is Structured

Vernard Sharbney — Sat, 03 Oct 2026 11:38:47 +0000

This is a submission for the Sanity Challenge, Path One: Ship an Agent That Queries Real Content

What I Built

Security Benchmark Explorer is an AI agent that helps security engineers and AI researchers explore a 54-case benchmark of vulnerability detection test cases — including 5 deliberate false-positive traps designed to distinguish data-flow reasoning from pattern matching.

A generic LLM knows what SQL injection is. It does not know which of my 54 cases are vulnerable, which are safe, what difficulty tier each falls into, or why a specific case was classified the way it was. That knowledge lives in a structured Sanity dataset, and the agent reads it through Sanity Context MCP.

The agent answers five kinds of questions that a keyword search cannot:

Exact case lookup: "Explain the rationale for EVAL-004" → requires a caseId == "EVAL-004" filter
Compound filtering: "Show me all hard-difficulty SQL Injection cases" → requires category == "SQL Injection" && difficulty == "hard"
Pattern matching on IDs: "Which cases are false-positive traps?" → requires caseId match "TRAP-*"
Field-by-field comparison: "What's the difference between CMD-004 and CMD-005?" → requires reading two documents and comparing the vulnerable and rationale fields
Aggregation over structured data: "How many vulnerable cases are in the benchmark?" → requires count() on a boolean field

Try it: security-benchmark-explorer.vercel.app/explorer

Demo

Deployed app: security-benchmark-explorer.vercel.app/explorer

Query 1 — Exact case lookup

You: Explain the rationale for EVAL-004

Agent: EVAL-004 is a hard-difficulty Code Injection case. The code is expression = OPERATIONS[user_input] followed by result = eval(expression). It's vulnerable because the attacker controls the lookup key and therefore potentially selects executable expressions.

A keyword search for "EVAL-004" returns nothing — the case ID only exists in a structured field.

Query 2 — Compound filter across two fields

You: Show me all hard-difficulty SQL Injection cases

Agent: The hard-difficulty SQL Injection cases are SQL-004 and SQL-005. SQL-004 is vulnerable because it parameterizes the query values but still interpolates the column name from user input. SQL-005 uses the same structure but validates the column against an allowlist, making it safe.

This is a GROQ query: *[_type == "benchmarkCase" && category == "SQL Injection" && difficulty == "hard"]. Two field filters, one result set. A keyword search for "hard SQL Injection" returns nothing useful — it can't distinguish the vulnerable case from the safe one in the same category.

Query 3 — The false-positive traps

You: Which cases are false-positive traps?

Agent: The 5 false-positive traps are TRAP-001 through TRAP-005 — all safe code designed to look dangerous. TRAP-001 is subprocess.run(["ls", user_input]) — safe because no shell is invoked. TRAP-002 uses secrets.token_hex(32). TRAP-003 parameterizes both values. TRAP-004 evals a constant. TRAP-005 uses MD5 for a file checksum, not password hashing.

A keyword search for "false positive" returns zero results — the phrase doesn't appear in any document text.

Query 4 — Two-case comparison

You: What's the difference between CMD-004 and CMD-005?

Agent: CMD-004 is subprocess.run(["cat", filename], check=True) — safe, because user input is passed as an argument, not shell syntax. CMD-005 is command = ["cat", user_input]; subprocess.run(command, shell=True) — vulnerable, because shell=True changes the security properties of the invocation. The only difference is shell=True.

This requires reading two documents and comparing their vulnerable and rationale fields.

Query 5 — Aggregation

You: How many vulnerable cases are in the benchmark?

Agent: 26 of the 54 benchmark cases are vulnerable. 28 are safe.

This is count(*[_type == "benchmarkCase" && vulnerable == true]). A Knowledge Base of prose documents can't answer this. Only a structured dataset can.

Code

Repository: github.com/CrossDomainSolutionArchitect/kaggle-security-benchmark-explorer

The repo contains the Sanity Studio (in studio/), the Next.js agent app (in web/), and the 54-case dataset in NDJSON format (in data/).

Key files:

studio/schemaTypes/benchmarkCase.ts — the schema (6 fields)
data/benchmark_cases.ndjson — the 54-case dataset
web/src/lib/sanity-context.ts — the MCP client
web/src/app/api/explorer/route.ts — the agent route
web/src/app/explorer/page.tsx — the chat UI

How I Used Sanity

I built one document type — benchmarkCase — with six fields:

Field	Type	Purpose
`caseId`	string	e.g., `SQL-001`, `CMD-004`, `TRAP-002`
`code`	text	The Python snippet
`vulnerable`	boolean	Ground-truth label
`category`	string	Vulnerability type
`difficulty`	string	easy / medium / hard
`rationale`	text	Why this classification

The vulnerable boolean is the critical field. Without it, you can't distinguish subprocess.run(["cat", filename]) (safe) from subprocess.run("cat " + filename, shell=True) (vulnerable). Both look similar. Only the structured ground-truth label separates them.

I pointed Sanity Context at the benchmarkCase dataset source, not a Knowledge Base. This was a deliberate choice: the challenge's use case was structured lookups, and Knowledge Bases serve semantic search over prose. My data has exact field values (caseId, category, difficulty, vulnerable) that require exact-match filtering, not similarity search.

The Sanity Context MCP endpoint exposes the GROQ tools to the agent. The agent calls groq_query with a filter, gets structured documents back, and reasons over them. It never guesses — it always queries.

The endpoint's custom instructions tell the agent to always cite case IDs, reference the 5 TRAP cases for false-positive questions, reference CMD-004 and TRAP-001 for the variable-name bias finding, and never invent case IDs.

Sanity Project Details

Project ID: 2el69ou3
Organization ID: o9cl071wg
Dataset: production (public)
Document type: benchmarkCase
Total documents: 54
MCP endpoint: security-benchmark-mcp

Public dataset URL:

View all 54 cases in the Sanity Content Lake

You can also view the deployed Studio at:
kaggle-security-benchmark-explorer.sanity.studio

Agent Session

I built this agent in GitHub Codespaces without using an AI coding CLI, so I have no Agent Session transcript to embed. The full build history is visible in the repository's commit log.

Why This Only Works Because the Content Is Structured

This is the challenge's core requirement, so let me be explicit about it.

A keyword search for "EVAL-004" returns nothing. The case ID only exists in a structured field.
A keyword search for "hard SQL Injection" returns nothing useful. It can't filter on difficulty == "hard" and category == "SQL Injection" simultaneously.
A keyword search for "false positive" returns nothing. The phrase doesn't appear in any document text — the TRAP cases are identified by their caseId pattern.
A question like "How many vulnerable cases are there?" can only be answered by counting a boolean field. No amount of prose can support that.

The agent works because the data is structured. A keyword search over the same content would return nothing.

What I'd Build Next

Three additions I'd make with more time:

Model performance as a related document type. Each case could reference the models that failed it. This would let the agent answer "Which models failed TRAP-001?" — a query that spans two structured document types.
Vulnerability relationships as references. Model relatedVulnerabilities between cases so the agent can answer "What other cases are similar to SQL-004?" using graph traversal.
App SDK interface. Build a Studio app that shows the benchmark as a filterable table, so security teams can explore the data without the chat interface.

Built With

Sanity Context MCP · Next.js 16 · Vercel AI SDK · Gemini 2.5 Flash · TypeScript · Tailwind CSS

Built by

vernard_sharbney_4c39f22b

sanitychallenge

The Cheapest, Fastest Model Is the Best Security Reviewer. I Tested 8 to Find Out.

Vernard Sharbney — Fri, 02 Oct 2026 15:33:12 +0000

This is a submission for the Kaggle Benchmarking Challenge

What I Benchmarked

I built a 38-case security vulnerability detection benchmark on Kaggle that tests whether LLMs can identify vulnerabilities in Python code with deliberate false-positive traps designed to distinguish data-flow reasoning from pattern matching.

The itch came from studying for CEH v13. Every week, another "AI security assistant" launches claiming to replace human code review. I wanted to know: do LLMs actually reason about security, or do they just recognize recognizable shapes?

Most security benchmarks test textbook cases. Real code review is harder. Consider these three snippets:

# Case 1: Looks dangerous, is safe
subprocess.run(["cat", filename])  # no shell → no injection

# Case 2: Looks safe, is dangerous
expression = OPERATIONS[user_input]
result = eval(expression)  # user controls what gets eval'd

# Case 3: Same token, different risk
eval("2 + 2")           # safe — hardcoded
eval(user_input)        # dangerous — attacker-controlled

A model that passes textbook tests but fails these three is not ready for security work.

Benchmark Design
38 cases across 12 vulnerability categories:

SQL Injection (5) — including column-name injection via f-strings

Command Injection (5) — including shell=True with list args

Hardcoded Secrets (4) — including config vs. credential distinction

Insecure Deserialization (5) — including trusted vs. untrusted sources

Code Injection / Eval (4) — including restricted-globals eval

Password Hashing (4) — including MD5 checksums vs. MD5 password hashes

Path Traversal (3) — including Path.resolve() containment

SSRF (3) — including URL allowlisting

ReDoS (2) — nested quantifiers

JWT Algorithm Confusion (2) — algorithms=["HS256", "none"]

Authorization Bypass (2) — falsy-comparison bugs

TOCTOU Race Conditions (2) — check-then-use patterns

5 explicit false-positive traps

Three difficulty tiers: easy (16), medium (19), hard (19).

Metrics measured per run:

Binary accuracy (vulnerable vs. safe)

True Positive Rate / False Negative Rate (missed vulnerabilities)

False Positive Rate (wrongly flagged safe code — the metric that matters most for triage)

Vulnerability naming accuracy

Per-difficulty breakdown

The capability I set out to measure wasn't "can the model detect SQL injection" — that's saturated. I wanted to measure whether the model can distinguish dangerous code from code that merely looks dangerous. That's the actual skill a security reviewer needs.

Models Tested

I tested 9 models across 5 providers, spanning three tiers lightweight, flagship, and reasoning. The lineup was chosen to answer three specific questions:

The three questions:

Do flagships beat lightweight models at security triage — or is the pattern-matching ceiling low enough that cheap models suffice?
Do reasoning models outperform standard ones on security tasks that require multi-step inference?
What's the cost/latency tradeoff at each tier — and does the most accurate model actually make sense in production?

This lineup gives me a clean read on all three. If a $0.02 model matches a $0.47 model, that changes how security teams should build triage pipelines. If reasoning models fail, that's a finding about the maturity of the capability.

Findings

Qwen's score is misleading see Finding 3.

Insight 1: The Cheapest, Fastest Model Wins at Production Triage
Gemini 2.5 Pro costs 5.8x more than Claude Haiku 4.5 and is 30x slower — for the same 0.92 score.

This is the finding that surprised me most. I expected the flagship Gemini model to pull ahead on hard cases. It didn't. Both scored 0.92. Both passed 35 of 38 assertions. The difference is that one costs $0.466 per run and takes 6 minutes, and the other costs $0.080 and takes 12 seconds.

If you're building a security triage pipeline scanning 10,000 files:

Gemini 2.5 Pro: $4,660 per scan, 1,036 hours of compute
Claude Haiku 4.5: $800 per scan, 34 hours of compute

Same accuracy. 6x cheaper, 30x faster. The production choice is obvious.

GPT-5.4 is the interesting middle ground. It scored 0.97 - the joint highest - at 27 seconds and $0.105. If you need maximum accuracy and reasonable latency, that's the pick. If you need maximum throughput at scale, Haiku wins.

GPT-5.4 mini is the budget option at $0.023 and 0.82 accuracy. For pre-filtering large corpora before human review, that tradeoff might be worth it. It depends on what your false-positive tolerance is.

Insight 2: Latency Is a Hidden Failure Mode — and Every Benchmark Ignores It
Three models took longer than 5 minutes per full run:

Gemini 2.5 Pro: 372.58s
Qwen3 Next 80B: 367.01s
Gemini 3.7 Flash: 304.81s

For a tool meant to fit into a developer's workflow, a 5-minute review per file means abandonment. A 12-second review (Haiku) means it becomes part of the process. Security teams should treat latency as a first-class metric, not an afterthought.

A model that scores 0.97 in 5 minutes is functionally worse than a model that scores 0.92 in 12 seconds — because the second one actually gets used. Leaderboards reward accuracy; users reward responsiveness.

Insight 3: Format Compliance Skews Every LLM Benchmark
Qwen3 Next 80B scored 0.68. Look at what actually happened:
`Qwen said:

VULNERABLE: YES
Vulnerability: SQL injection`
The model was correct. But my regex expected VULNERABLE: YES without markdown bold. Every assertion failed — 0/38. Not because Qwen was wrong, but because it formatted its output differently.

This is a universal problem with LLM benchmarks — they measure format compliance as much as reasoning capability. A model can be correct and score zero. Anyone building evaluation infrastructure needs to handle output-format variance explicitly, or risk misjudging models by 30+ points.

Qwen's true detection capability is likely much higher than 0.68 — but the formatting failure makes it unusable as-is in an automated pipeline. That's a real operational finding, not a benchmark artifact.

Insight 4: Reasoning Models Are Not Ready for High-Throughput Triage
Both DeepSeek-R1 and Claude Sonnet 4.5 errored out. DeepSeek failed after only 3 of 38 cases — likely a token or time budget exhaustion caused by its long chain-of-thought outputs.

For a security tool that needs to process thousands of files daily, models that require reasoning traces to be serialized and returned are operationally risky. A tool that fails on 1 in 4 inputs is worse than a slightly less accurate tool that always responds.

Grok 4.20 Reasoning was the exception — it completed the run at 0.95 with 80-second latency. So the finding isn't "reasoning models fail" — it's "reasoning models are variable in their operational reliability," and that variance matters at scale.

Insight 5: Even the Best Models Fail on the Same Case
Gemini 3.7 Flash scored 0.97 — one failure out of 38. That single failure was CMD-004:
filename = user_input subprocess.run(["cat", filename], check=True)

This is safe. The user controls the filename, and yes, that's a validation concern — but there's no command injection here. No shell. No traversal. The cat command reads exactly the file it's told to read. The model flagged it as vulnerable because the variable was named filename.

GPT-5.4 failed the exact same case. So did Grok, Haiku, and Gemini 2.5 Pro. Five models, one shared false positive.

This is the universal failure mode: variable-name bias. When a variable is called user_input, filename, or user_path, all models reflexively flag it — regardless of whether the operation is actually dangerous. This is pattern matching, not reasoning.

And the flip side is worse. The same model missed EVAL-004 — expression = OPERATIONS[user_input]; result = eval(expression) — which is vulnerable. The user selects which expression gets evaluated. But because the syntax doesn't look like eval(user_input), the model gave it a pass.

False positives generate noise. False negatives generate breaches. The model is biased toward both.

What I'd Measure Next

Variable-name swap experiment. Rename user_input to config_value in the same snippet. If the model stops flagging it, we've proven variable-name bias. If it still flags it, the model is reasoning about data flow. This single experiment would settle whether LLMs are doing real analysis or shape recognition.
Calibration measurement. Ask each model for a confidence score alongside its verdict. When a model says "95% confident," how often is it right? Overconfidence is a critical safety failure for security triage. If a model is wrong 15% of the time but says "100% confident" every time, it's dangerous — not useful.
Format-normalized scoring. Rebuild the benchmark with a parser-agnostic layer that extracts verdicts regardless of markdown, JSON, or plain-text formatting. Re-run Qwen3 to see its true capability. This would help the entire LLM evaluation community, not just this benchmark.
Multi-turn triage. Give the model a full file, ask it to triage, then ask "why did you flag this?" If the reasoning contradicts the verdict, the model is pattern matching — regardless of how accurate it looks on the leaderboard.

My Benchmark

Security Vulnerability Detection v2 on Kaggle

Full notebook with source data

The benchmark contains:

38 code snippets with ground-truth labels
12 vulnerability categories
3 difficulty tiers (easy / medium / hard)
5 explicit false-positive traps
Full source code and rationale for every case
Live leaderboard across 7 completed models

Fork it. Add your own cases. Test your own models. The point of a benchmark isn't to have the final word it's to start a better conversation. Every case, every rationale, and every assertion is public so anyone can extend this.

🛡️ CDSA | Cybersecurity & Digital Safety Hub

Vernard Sharbney — Sat, 22 Nov 2025 04:00:35 +0000

Welcome to CDSA's space for future cyber defenders.
If you're serious about protecting systems, spotting threats, and keeping the digital world safe — pull up a chair.

🚀 Your Cybersecurity Launch Pad

📚 Theory & Fundamentals

Percipio Learning Channel: Complete cyber foundation 🔗 Access Theory Materials

🔥 Hands-On Labs

Ethical Hacker v12 Lab: Real penetration testing environment 🔗 Launch Sandbox
- Active: Nov 2025 - Jul 2026
- Intermediate penetration testing
- Practical skill validation

💡 What You'll Master

⚔️ Core Cyber Skills

Threat identification & analysis
Network security fundamentals
Incident response procedures
SIEM tool basics
Digital safety protocols

🎯 Certification Ready

CEH (Certified Ethical Hacker) preparation
Hands-on penetration testing
Industry-recognized skills
Portfolio-worthy projects

🛠️ Learning Path

Phase 1: Foundation (Weeks 1-4)

Complete Percipio theory modules
Master cyber basics & terminology
Understand attack vectors

Phase 2: Practical (Weeks 5-8)

Start Ethical Hacker labs
Practice in safe sandbox
Build first penetration tests

Phase 3: Advanced (Weeks 9-12)

Complex attack scenarios
Defense strategies
Incident response drills

🔥 Start Your Cyber Journey

No fear-mongering. No complicated jargon.
Just practical cyber skills for a world that stays online 24/7 🌐🔥

Next Steps:

Bookmark both Percipio links
Start with theory foundation
Join Ethical Hacker lab
Connect with CDSA cyber community

Let's build a safer digital Africa — one defender at a time.

Follow @cdsa for cyber threats analysis, defense techniques, and community challenges.

#CDSA #Cybersecurity #EthicalHacking #CyberDefense #DigitalSafety #Percipio

Web Development Community Track

Vernard Sharbney — Sat, 22 Nov 2025 03:12:16 +0000

Master web development with IBM's free, industry-recognized courses. Zero cost, maximum impact.

🎯 Core Learning Paths

⚛️ Frontend & React

- React Bootcamp - Percipio: Here
- NodeJs Bootcamp - Percipio: Here
- Restful Webservices Bootcamp - Percipio: Here

React Basics - Cognitive Class: cognitiveclass.ai/courses/react-101
Node.js Essentials - Cognitive Class: cognitiveclass.ai/courses/nodejs-essentials

🐍 Python & Backend

Python for Data Science - Cognitive Class: cognitiveclass.ai/courses/python-for-data-science
Django with IBM - IBM Skills: yourlearning.ibm.com/courses?q=django

🗄️ Databases & APIs

📊 Data & APIs

SQL & Relational Databases 101 - Cognitive Class: cognitiveclass.ai/courses/db0101en
REST API Fundamentals - Cognitive Class: cognitiveclass.ai/courses/rest-api-fundamentals

☁️ Cloud & DevOps

🔧 IBM Cloud Essentials

IBM Cloud Essentials - Cognitive Class: cognitiveclass.ai/courses/ibm-cloud-essentials
Docker Essentials - Cognitive Class: cognitiveclass.ai/courses/docker-essentials
Kubernetes Fundamentals - Cognitive Class: cognitiveclass.ai/courses/kubernetes-fundamentals

🛠️ Tools & Certifications

🎓 IBM Badges & Certs

IBM Full Stack Developer - Professional Certificate: cognitiveclass.ai/learning-paths/ibm-full-stack-cloud-developer
IBM DevOps & Software Engineering - Professional Certificate: cognitiveclass.ai/learning-paths/devops-software-engineering

🔨 Essential IBM Tools

IBM Watson APIs - AI Integration: ibm.com/watson/developer
IBM Cloud Foundry - App Deployment: cloud.ibm.com

🔥 Start Building Today

Pick one course → Earn your first badge → Build momentum.

Start with Python for Data Science
Join CDSA Discord for support
Complete one project per month

Earn IBM badges. Build real skills. Get hired. 🚀

Follow @cdsa for IBM course updates and community projects.

#CDSA #WebDev #IBM #CognitiveClass #FreeLearning #CloudComputing

The AI/ML Learning Path (Sprints-Based, Zero-Cost, Industry-Solid) Track

Vernard Sharbney — Sat, 22 Nov 2025 02:38:27 +0000

AI/ML Engineering Track

If you want to learn AI, ML, Deep Learning, Computer Vision, Deployment, APIs, fast, AND build a real project that actually matters… welcome home.

🔥 The AI/ML Learning Path (Sprints-Based, Zero-Cost, Industry-Solid)

Built to turn beginners into legit AI engineers with a portfolio that hits.

🧭 Sprint 1 — Get the Basics Locked (Python + Data Analysis + Git)

Goal: Understand Python, data, and version control.
Tools: Kaggle, CognitiveClass.ai, GitHub.

📚 Must-Do Resources

Python + Pandas (Kaggle)
https://www.kaggle.com/learn/python
https://www.kaggle.com/learn/pandas
CognitiveClass — Data Science with Python
https://cognitiveclass.ai/courses/data-science-hands-open-source-tools
Bonus: Intro to Jupyter Notebooks
https://jupyter.org/

🧩 AgriScan Build Task

Analyze a sample soil dataset:

Calculate pH ranges
Classify soil types
Visualize nutrient distribution

Push your notebook to GitHub.

🔥 Sprint 2 — Machine Learning Core (Scikit-Learn Mastery)

Goal: Build prediction models confidently.
Tools: Scikit-Learn.

📚 Must-Do Resources

CognitiveClass — Machine Learning with Python
https://cognitiveclass.ai/courses/machine-learning-python
Scikit-Learn Official Tutorials
https://scikit-learn.org/stable/user_guide.html

🧩 AgriScan Build Task

Build a basic Crop Recommendation Model:
Input: soil features (pH, potassium, nitrogen, moisture)
Output: crop suggestion

Train → Test → Evaluate → Push to GitHub.

🧠 Sprint 3 — Deep Learning & Computer Vision (The AgriScan Engine)

This is where we build the actual brain of AgriScan.

📚 Must-Do Resources

CognitiveClass — Deep Learning Fundamentals
https://cognitiveclass.ai/courses/introduction-deep-learning
CognitiveClass — Computer Vision with Python
https://cognitiveclass.ai/courses/computer-vision-with-python
Fast.ai — Practical Deep Learning for Coders
https://course.fast.ai/

🌍 External Data Resources

PlantVillage Dataset (disease images)
https://www.kaggle.com/datasets/emmarex/plantdisease
Google Colab (free GPU)
https://colab.research.google.com/

🧩 AgriScan Build Task

Build a CNN model to classify crop diseases.
Start simple → build up to an AgriScan-level architecture.

Reference research:

High-accuracy AgriScan CNN Model (LDDTA) https://paperswithcode.com

(Don’t stress — we simplify it.)

🏗️ Sprint 4 — Deploy Models as APIs (FastAPI + Containers + Cloud)

Real AI engineers deploy, not just train models.

📚 Must-Do Resources

FastAPI Docs
https://fastapi.tiangolo.com/
CognitiveClass — APIs & Microservices
https://cognitiveclass.ai/courses/api-microservices
Docker Essentials
https://cognitiveclass.ai/courses/docker-essentials
AWS Cloud Practitioner (Percipio placeholder)
Replace with your org's Percipio link here

🧩 AgriScan Build Task

Deploy your ML model as a live API:

Create a /predict endpoint
Accept image uploads
Return JSON predictions
Containerize with Docker
Deploy to:
- HuggingFace Spaces OR
- AWS Free Tier OR
- Railway.app

⚙️ Tools Every AgriScan Engineer Should Touch

These are non-negotiables:

💾 Notebooks

Google Colab
Jupyter Notebook
Kaggle Kernels

⚡ ML / DL Frameworks

Scikit-Learn
TensorFlow
PyTorch
Fast.ai

📊 Big Data & Distributed Processing

Apache Spark
https://spark.apache.org/
Databricks Community Edition
https://community.cloud.databricks.com/

☁️ Cloud + Architecture Skills

AWS Free Tier
https://aws.amazon.com/free/
“Good Architect” fundamentals
https://aws.amazon.com/architecture/

🔚 What Skills You’ll Have at the End

Every member of the CDSA AI/ML Squad will be able to:

🧪 Technical

✔ Build ML models (Regression, Classification, Clustering)
✔ Build CNNs for image classification
✔ Work with PlantVillage + soil datasets
✔ Use Colab for GPU training
✔ Engineer features from raw agricultural data
✔ Train, validate, and tune DL models
✔ Build and deploy APIs using FastAPI
✔ Containerize apps with Docker
✔ Deploy models to cloud (HF Spaces / AWS / Railway)
✔ Version control using Git/GitHub
✔ Use Apache Spark for big-scale processing

🌍 AgriTech Domain

✔ Understand soil science basics
✔ Understand real crop disease patterns
✔ Build recommendation engines
✔ Work with agricultural datasets
✔ Adapt AI solutions for rural environments

💼 Career

✔ A real GitHub portfolio
✔ Multiple CognitiveClass badges
✔ Kaggle projects
✔ A deployed API you can demo
✔ Skills aligned with junior AI Engineer / ML Engineer roles

🚀 Final Notes

This isn’t a “take a course and chill” track.
This is a build-in-public, fast-learning, problem-solving squad.

Every sprint ends with:

A GitHub push
A demo
A micro-deliverable for AgriScan

If you're ready to build something that actually matters to farmers here in SA — jump in.

ATS CV & Resume Optimization Track

Vernard Sharbney — Fri, 21 Nov 2025 10:46:22 +0000

📌 What This Track Is About

This track is built to help you create a real-world, recruiter-ready, ATS-friendly CV that actually passes screening systems and gets interviews.

Whether you’re applying for tech roles (Dev, Cyber, AI, Data, Cloud) or non-tech roles, this track makes sure your CV is clean, structured, and aligned with international standards.

📄 What You’ll Learn

✔ How ATS (Applicant Tracking Systems) filter CVs
✔ Keywords, formatting, and structure that pass automated screening
✔ How to tailor your CV for tech roles
✔ How to quantify your achievements
✔ How to remove “CV killers” that reduce ATS scores
✔ How to test and improve your CV using AI tools
✔ How to prepare your CV for GitHub, LinkedIn, and job boards

🛠 Core Tools & Resources (Free)

1️⃣ Google Resume Template (Clean + ATS Friendly)

Start with a globally recognized CV structure. 🔗Google ATS CV Here

2️⃣ Jobscan — Test Your CV Against Real Job Descriptions

Upload your CV + job description → Get your ATS score and improvements.
🔗 Jobscan: Here

3️⃣ IBM ATS & Resume Writing Course (Free Certificate)

Short, practical training that teaches CV structure, keywords, and ATS logic.
🔗 IBM Learning Path: Here

📚 Track Deliverables

By the end of this track, you will have:

✅ A complete ATS-ready CV
✅ A Jobscan score of 70%+
✅ A tailored version of your CV for your preferred job role
✅ A portfolio-ready skills section
✅ A clean, recruiter-friendly format
✅ A free IBM badge (optional but recommended)

✨ This Track Is For You If…

You’re job hunting
You’re applying for internships, grad programs, or gigs
You’re entering hackathons and need a clean bio
You want a CV that actually gets read
You’re switching careers into tech

🚀 How This Track Works

Start with the Google Template → build your base CV.
Run it through Jobscan → fix the issues using the score report.
Take IBM’s ATS course → understand the hiring logic.
Get peer review inside the CDSA WhatsApp Community.
Submit your final CV for certification in our community portal.

Join the Canva Africa Design Challenge

Vernard Sharbney — Mon, 17 Nov 2025 21:11:08 +0000

Welcome friend - are you ready to design templates that help small businesses, Solopreneurs, and Freelancers level-up and stand out?

Think WhatsApp product menus, email templates, business cards, brand kits, social video templates and let's not forget those creator rate cards and yes, even that link in bio. Ready to lock in? Use Canva to design those must-have templates for Africa by Africa and submit as many as you like before 15 December 2025.

Your design could win you a share of US$10,000, 1:1 Mentorship with Canva designers, exclusive Canva Swag and your templates will be published on Canva
Happy designing 💜

Submit your entry
(opens in a new tab or window)
Terms and conditions

Welcome to CDSA Developer Bootcamp – Get Started Today! 🚀

Vernard Sharbney — Mon, 17 Nov 2025 12:28:44 +0000

Welcome & Congratulations! 🎉
You are now part of the CDSA Developer Community on Dev.to! As a member, you have exclusive access to our AI & Web Development Bootcamp, designed to empower you with future-ready skills and industry-recognized certifications.

Here’s How to Get Started:

1️⃣ Complete Your Registration
Ensure your Dev.to profile is fully set up and that you can access our organization page: CDSA on Dev.to

2️⃣ Follow the Bootcamp Learning Paths:

A) IBM SkillsBuild Certification Paths (Certificates required)

Web Development: Start Here

AI Fundamentals: Start Here

AI Student resource: Start Here

B) Percipio ReactJS Bootcamp Study Group

Join the ReactJS learning path: Percipio Platform

3️⃣ Track Your Progress & Certificates

Make sure to complete each module and download your certificates. These are key milestones to demonstrate your skills to future employers and showcase your dedication.

4️⃣ Join the CDSA Community & Ask Questions

Share your progress, ask questions, and collaborate with peers within our Dev.to organization. Networking is a crucial part of skill-building.

5️⃣ Stay Updated

All bootcamp updates, hackathon announcements, and new learning resources will be shared via email and our Dev.to organization page.

We’re excited to see the innovative solutions you will build and the skills you will gain. Let’s make this bootcamp a transformative experience!

If you have any issues accessing resources or registering, reply to this email, and we’ll assist immediately.

Let’s engage!
📞 WhatsApp
📘 Facebook
🔗 LinkedIn (CDSA)
🌐 www.vcdsa.co.za
📧 info@vcdsa.co.za

🚀 Join the CDSA Developer Challenge Hub — Learn, Build & Win Experience + Moola!

Vernard Sharbney — Sun, 16 Nov 2025 20:46:43 +0000

Are you ready to level up your tech skills and launch real projects that matter? CDSA (Cross Domain Solution Architect) is empowering Africa’s next generation of developers through AI, web innovation, and applied technology challenges.

We’re inviting students, junior developers, and tech enthusiasts to join our 1-Month Web Development Bootcamp and ongoing challenge hub. This is more than learning — it’s about building your portfolio, gaining real-world experience, and connecting with a global tech community.

🔹 What You’ll Get

Hands-On React.js Training: Build responsive web apps and personal portfolios
Live Project Deployment: Launch websites on Vercel, Netlify, or GitHub Pages
Hackathon Experience: Test your creativity and speed in real coding competitions
Freelance-Style Gigs: Work on practical projects to gain credibility and experience
Industry-Recognized Certifications: From Vodafone, IBM, and Microsoft — absolutely free!

🔹 How to Join

Register for the Bootcamp:
Fill out the official form
Join the Dev Community Hub:

Sign up at dev.to
Go to Organization Settings
Paste this secret code:

8a3f1dfef6f8de1c3f0ec65f22c60ae2deb81d50d0b7c8aaa05a1e72b55789a5646433b1c8732784f7d7f6444732ee17112c

Get Your Portal Credentials: After completing the steps above, you’ll receive access to the student portal, starter projects, and Week 1 schedule.

🔹 Why Join CDSA?

Future-Ready Skills: Learn technologies that matter for today and tomorrow
Career Launchpad: Build a portfolio, get hackathon experience, and explore freelance gigs
Global Connections: Engage with mentors, industry experts, and the UN/ITU AI for Good network
Impact Africa: Use your skills to solve real-world challenges and contribute to the digital economy

🔹 Connect with Us

📞 +27 69 142 4153
🌐 www.vcdsa.co.za
📧 info@vcdsa.co.za

CDSA — Building Africa’s Future Developers, One Challenge at a Time!

🚀 CDSA 1-Month Web Development Bootcamp: Skills Portfolio Opportunity. — Learn, Build & Win Experience + Moola!

Vernard Sharbney — Sat, 18 Oct 2025 10:24:20 +0000

🔥 UPDATED BOOTCAMP (MISSION-ALIGNED & SOCIAL-MEDIA READY)

The CDSA 1-Month Web Development Bootcamp isn’t just another coding class — it’s a launchpad for youth innovators.
Powered by CDSA × GEP × UN/ITU AI for Good, this zero-fluff, hands-on experience takes you from beginner to deploy-ready creator while preparing you for real business and community impact.

Over four intensive weeks, you’ll learn how to code, create, build, deploy, and lead — all while gaining access to certification pathways from Vodafone, IBM, and Microsoft for FREE.

This is the real deal.
Practical. Team-driven. Impact-focused. Future-building.

🚀 What You’ll Do

🔥 Build and deploy your own responsive web apps
🔥 Master React.js fundamentals + modern workflows
🔥 Launch real projects on Vercel, Netlify, GitHub Pages
🔥 Compete in innovation mini-hackathons
🔥 Complete real gig-style builds to grow your portfolio
🔥 Get mentored on digital branding + professional presence
🔥 Begin your journey into entrepreneurship (Phase 2 pipeline)

🌍 Outcomes (Real. Tangible. Career-making.)

By the end of the bootcamp, you will walk away with:

✅ A fully deployed personal portfolio website
✅ Real React.js project experience
✅ Team + GitHub collaboration skills
✅ Hackathon exposure + gig-work readiness
✅ A foundation for AI, startup building, and Phase 2 (NPO + Business Launchpad)
✅ Alignment with UN SDGs & “AI for Good” innovation principles
✅ Direct bridge into the CDSA × GEP entrepreneurship pipeline

This bootcamp doesn’t end at “learning.”
It ends at opportunity — skills, a portfolio, and a pathway to build real businesses and community solutions.

📞 Contact Details

📞 +27 69 142 4153
🌐 www.vcdsa.co.za
📧 info@vcdsa.co.za

StartUps-Forum

Vernard Sharbney — Wed, 13 Aug 2025 08:39:57 +0000

As dev community member, I believe it would be beneficial to us all if dev platform can have something like "startup forums" such channel discus business-value-driven perspectives, fueling each other to think business and turn every idea to a valuable solution

BrandForge AI-generates business logoS

Vernard Sharbney — Thu, 31 Jul 2025 13:42:14 +0000

This post is my submission for DEV Education Track: Build Apps with Google AI Studio.

What I Built

An AI-powered application that generates business logos and a comprehensive branding guide using Gemini. Users can input their business details to receive multiple logo options and detailed design specifications.

Demo

Live deployed

My Experience

Googl AI studio solves the needs to ideate and sketch the idea which is time consuming.
Highly recommend the use of Google AI Studio