DEV Community: ABHINASH SAHOO

Building CivicGemma: A Tamper-Evident E-Voting Microservices Platform with Gemma 4 🗳️

ABHINASH SAHOO — Sat, 31 Oct 2026 07:41:07 +0000

🚀 TL;DR

During Hacktoberfest Hack Day Bhubaneswar × DatrixLabs, I built CivicGemma — an open-source, full-stack microservices e-voting pilot system designed specifically for local body elections (Panchayats, Municipalities, and Wards).

It combines Java 21 & Spring Boot 3.4 microservices, Angular 22, and Gemma 4 multimodal AI to deliver double-voting prevention, cryptographic SHA-256 ballot sealing, and multilingual voter assistance.

💡 The Problem: Why Local Body Elections?

Grassroots democracy is where policy directly impacts daily life — from local roads to sanitation and water supply. However, local body elections face unique logistical hurdles:

Paper Ballot Inefficiencies & Fraud: High printing costs, slow manual counting, and vulnerability to tampering.
Double-Voting Risks: Malicious voters registered across adjacent wards attempting multiple ballots.
Information Asymmetry: Citizens often don't know who their ward candidates are or what their local manifestos promise.

We asked: Can we build a transparent, auditable, and accessible digital voting platform that guarantees ballot integrity while empowering voters with AI?

That was the birth of CivicGemma.

🏗️ System Architecture: The Microservices Ecosystem

Rather than building a monolithic prototype, we architected CivicGemma around the Database-per-Service pattern using Spring Cloud 2024 and Spring Boot 3.4.2:

             ┌─────────────────────────┐
               │  Angular 22 Frontend    │
               └────────────┬────────────┘
                            │ HTTP / REST
                            ▼
               ┌─────────────────────────┐
               │   Spring Cloud Gateway  │ (Port 8080)
               └────────────┬────────────┘
                            │ lb://

┌──────────────┬─────────────┼─────────────┬──────────────┐
▼ ▼ ▼ ▼ ▼
┌──────────────┐┌────────────┐┌────────────┐┌────────────┐┌────────────┐ │ Auth Service ││Voter Service││Voting Service│Result Service│Audit Service│ │ (Port 8086) ││ (Port 8081) ││ (Port 8084) ││ (Port 8085) ││ (Port 8087) │ └──────┬───────┘└─────┬──────┘└─────┬──────┘└─────┬──────┘└─────┬──────┘ │ │ │ │ │ [Auth DB] [Voter DB] [Voting DB] [Result DB] [Audit DB]

Key Components:

Eureka Discovery Server (8761): Dynamic registry enabling microservices to locate each other without hardcoded IPs.
Spring Cloud API Gateway (8080): Reverse proxy handling routing, CORS policies, and centralized security.
7 Domain Services: Auth, Voter, Election, Candidate, Voting, Result, and Audit.
Database-per-Service: Each microservice has its own isolated MySQL database schema to ensure zero tight coupling.

🛡️ Core Innovation #1: Unbreakable Double-Voting Defense

In electronic voting, preventing race conditions (e.g., clicking "Vote" simultaneously across multiple tabs) is paramount. We implemented a three-tier defense:

Application Layer Check:

if (voteRepository.existsByElectionIdAndVoterId(dto.getElectionId(), dto.getVoterId())) {
    throw new IllegalStateException("Voter has already cast a ballot.");
}

Database Engine Constraint (The Hard Wall): We enforce a compound unique index constraint at the database level:

ALTER TABLE votes ADD CONSTRAINT uk_election_voter UNIQUE (election_id, voter_id);

Cryptographic SHA-256 Ballot Sealing: Every ballot generates a tamper-evident digital seal returned to the voter as a verifiable receipt:

String rawData = voterId + ":" + electionId + ":" + candidateId + ":" + timestamp + ":" + UUID.randomUUID();
MessageDigest digest = MessageDigest.getInstance("SHA-256");
byte[] hashBytes = digest.digest(rawData.getBytes(StandardCharsets.UTF_8));
// Returns 64-character hexadecimal receipt hash

🤖 Core Innovation #2: Gemma 4 Multimodal Civic AI

We leveraged Google's open-weights Gemma 4 model to solve two real-world accessibility challenges:

1. Multimodal Voter ID (EPIC) Verification

Elderly or rural voters can upload an image of their Electors Photo Identity Card (EPIC). Gemma 4's vision capabilities inspect the card, verify document legibility, extract the identifier, and cross-validate with the voter-service registry.

2. Multilingual Manifesto Explainer

Local voters can ask natural language questions in English, Hindi, or Odia:

"Who is running in Ward 12?"
"Summarize Candidate Arjun Sharma's key promises in 3 bullet points."
"Which candidate has promised better water drainage?"

Gemma parses structured candidate manifestos and delivers impartial, concise summaries.

🛠️ The Tech Stack
Domain  Technologies
Backend Java 21 LTS, Spring Boot 3.4.2, Spring Cloud 2024 (Eureka, Gateway, OpenFeign)
Frontend    Angular 22 (Standalone Components, SSR, Tailwind CSS)
Databases   MySQL (Isolated schema per microservice)
AI / ML Google Gemma 4 / Gemini API
Security    Stateless JWT (HMAC-SHA256), BCrypt, SHA-256
DevOps  Maven Multi-Module, Automated Batch Launchers (start-all.bat)

🧗 Challenges Faced & Lessons Learned
1. The JDK Compiler vs. Lombok Dilemma

During compilation, we hit a compiler error:

Fatal error compiling: java.lang.ExceptionInInitializerError: com.sun.tools.javac.code.TypeTag :: UNKNOWN



We discovered that the host environment was compiling with bleeding-edge JDK 25/26, which introduced breaking internal changes to com.sun.tools.javac.code.TypeTag that broke annotation processors like Lombok. We diagnosed and resolved this by pinning our toolchain to Eclipse Temurin JDK 21 LTS, restoring clean, reproducible builds.

2. Distributed State vs. Network Partitions

When voting-service records a ballot, it must sync hasVoted = true with voter-service. While OpenFeign handles synchronous calls gracefully, a network partition requires resilience. We architected fallback exception handlers and designed the schema so that the ballot ledger remains authoritative even if the voter metadata service experiences latency.

🔮 What's Next for CivicGemma?
Zero-Knowledge Proofs (ZKP): Implementing zk-SNARKs to achieve complete ballot unlinkability while mathematically guaranteeing eligibility.
Consortium Blockchain (Hyperledger Fabric): Moving the audit log service onto a distributed ledger so no single administrative authority can modify election logs.
Offline Polling Station Sync: Edge-caching for rural booths with intermittent connectivity.
🙏 Acknowledgements

Huge thanks to Major League Hacking (MLH), DatrixLabs, and the Hacktoberfest community for organizing this hackathon!

GitHub Repository: https://github.com/hira8969/E-Voting-Pilot-System-for-Local-Body-Elections
Live Demo Video / Project Link: https://lnkd.in/p/dKgcisNt

Drop a ❤️ if you found this interesting, and leave your thoughts on digital voting in the comments!

---

### 4. Optional Polish:
- **Cover Image:** You can click the **✨ Generate Image** button at the top to let DEV generate an AI cover banner for your post.
- **Preview:** Click the **Preview** tab next to "Edit" to see how clean the article looks before publishing.
- Click **Publish** (blue button at the bottom left) when you're ready!

GreenBuddy AI: The Haunted Garden

ABHINASH SAHOO — Wed, 28 Oct 2026 05:15:48 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

What I Built

👻 GreenBuddy AI: The Haunted Garden 🎃

What if your garden had a ghostly assistant to remind you what needs attention?

GreenBuddy AI is an open-source gardening assistant that uses local AI to generate gardening task suggestions based on the plants, location, and gardening space entered by the user.

For the Ghost in the Machine theme, I gave the gardening task tracker a Halloween makeover. The interface features spooky colors, a Haunted Garden banner, and ghostly messages when the AI generates gardening suggestions.

Beyond the Halloween appearance, the application helps users add suggested tasks, track completion, and retain their gardening progress after refreshing the page.

My inspiration was simple: combine the fun of Halloween with a practical everyday use case for open-source AI. 🎃🌱

Demo

The application currently runs locally.

To try it, start the Flask application and visit:

http://127.0.0.1:5000/tasks

This is a local development URL, not a publicly hosted demo. I'll add a screen recording or screenshots to showcase the experience.

Code

🌿 GitHub repository: https://github.com/AMLAN-07/GreenBuddyAI

Explore the project, try it locally, and contribute ideas for making gardening easier.

How I Built It

I built GreenBuddy AI using:

Python and Flask for the backend and API endpoints.
Ollama with a locally running language model for generating gardening task suggestions.
HTML, CSS, and JavaScript for the interactive interface and Halloween styling.
Browser local storage to retain gardening tasks and completion status across page refreshes.

I tested the main workflow: generating AI suggestions, adding a suggested task, marking it as completed, and refreshing the page to verify that tasks and completion status persisted.

The Halloween update builds on the existing gardening application rather than replacing its core functionality.

Why Does Open Innovation Matter?

Open innovation made it possible for me to explore AI beyond simply calling a closed, hosted API.

Running a model locally through Ollama gave me a way to experiment with AI-powered gardening suggestions while learning how to connect a language model to a real application. Open-source tools also make it easier for other developers to inspect, adapt, and contribute to the project.

For me, this project is a reminder that AI doesn't need to be mysterious or inaccessible. With open tools, we can experiment, learn, and build useful things one feature at a time.

The Spirit of It

Every haunted garden has its secrets. Mine has a ghostly assistant that turns gardening chores into a little Halloween adventure.

Behind the spooky colors and ghostly messages is a practical idea: caring for plants becomes easier when the next task is clear.

The ghost may haunt the garden, but the weeds won't pull themselves! 👻🌿

🌱 GreenBuddy AI: Your Local AI Gardening Assistant | Hacktoberfest Week 3

ABHINASH SAHOO — Thu, 22 Oct 2026 18:51:58 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

I built GreenBuddy AI, an AI-powered gardening assistant that helps beginners spend less time planning their garden and more time growing plants.

Gardening is rewarding, but remembering what to do, when to check plants, and how to plan regular maintenance can become repetitive. GreenBuddy helps simplify that process.

With GreenBuddy AI, users can:

🌱 Explore gardening advice tailored to their location and growing space.
🪴 Generate practical gardening tasks based on their plants.
🤖 Use AI-generated suggestions for activities such as checking soil moisture and inspecting leaves.
📅 Assign due dates to tasks and organize their gardening checklist.
✅ Save tasks and completion status in the browser, so their checklist remains available after refreshing the page.

The goal is simple: make gardening easier to maintain by reducing repetitive planning.

Demo

GreenBuddy AI currently runs locally on my development machine.

To try it, clone the repository, follow the setup instructions, start Flask and Ollama, and open the local application in your browser.

I haven't included a public deployment link because I haven't confirmed a publicly hosted demo.

Code

GitHub repository:

https://github.com/AMLAN-07/GreenBuddyAI

The project is open source, and I welcome feedback, suggestions, and contributions.

How I Built It

I built GreenBuddy AI using Python, Flask, HTML, CSS, JavaScript, and local AI inference.

My AI setup uses Qwen 2.5 3B through Ollama, allowing the application to generate gardening suggestions using a model running locally rather than depending on a paid hosted AI API.

The workflow is straightforward:

The user enters their plants, location, and growing space.
The Flask backend sends the information and gardening instructions to the local Qwen model through Ollama.
The model generates structured gardening task suggestions.
The backend validates the returned task data.
The user chooses which suggestions to add to their checklist.
The browser stores tasks and their completion status using local storage.

I also worked on adding AI-selected due-date offsets so tasks can have different suggested deadlines instead of assigning the same date to every task. This is intended to make the planner more useful for ongoing gardening routines.

I focused on keeping the workflow understandable, beginner-friendly, and practical.

Why Does Open Innovation Matter?

Open innovation made this project possible with tools I could experiment with and adapt to my needs.

Using an open-weight model through Ollama gave me a way to explore local AI inference without making a paid hosted API a requirement for generating suggestions.

It also gave me more control over the prompts, response format, validation, and integration with my Python application.

Open-source tools are especially valuable for learners like me because they make experimentation more accessible. I can inspect the code, understand how the components work together, improve the application, and share those improvements with other developers.

For me, open innovation means being able to learn by building something useful and making that work available to others.

The Lazy Payoff

GreenBuddy AI is designed to reduce the mental effort involved in planning recurring gardening activities.

Instead of starting with a blank checklist, a beginner can request suggestions and choose which tasks to add. Saving tasks in the browser also avoids having to recreate the checklist after every page refresh.

I haven't measured time savings yet, so I won't claim a specific number of minutes saved. My next step is to test the workflow with more gardeners and learn which suggestions and scheduling features are genuinely useful.

The aim is to make gardening routines easier to maintain, one small task at a time.

GreenBuddy AI

ABHINASH SAHOO — Tue, 13 Oct 2026 08:39:39 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

I built GreenBuddy AI, an AI-powered gardening assistant that helps beginners identify plants, get plant-care guidance, and plan a garden based on their location, season, and available growing space.

I wanted to make gardening easier for people who want to grow plants at home but don't always know which plants they have, how to care for them, or what they can grow in limited spaces like balconies.

GreenBuddy AI combines plant image identification with AI-generated gardening guidance to make getting started less intimidating.

The potential customers are beginner gardeners, balcony gardeners, and people who want practical help caring for their plants. In the future, the project could offer personalized gardening plans or additional plant-care features as a possible side hustle. I'm still exploring this opportunity and validating what users find most useful.

Demo

Try it locally: Run GreenBuddy AI on your computer to explore its features.

Project post: https://dev.to/amlan24/greenbuddy-ai-3259

The application is currently being tested locally, so a public deployed demo is not available yet.

Code

GitHub repository: https://github.com/AMLAN-07/GreenBuddyAI

The repository contains the source code for the project. Feedback is collected through an in-app form and saved locally for review.

How I Built It

I built GreenBuddy AI using Python and Flask for the backend, with HTML, CSS, and JavaScript for the user interface.

The project uses an open plant-identification model from Hugging Face to analyze plant images. I also use local AI tooling with Ollama and the Qwen 2.5 3B model for gardening assistance.

The main features include:

Plant identification:

Plant-care guidance: Get assistance with everyday gardening questions.

Gardening planner: Explore planting suggestions based on location, season, and growing space.
User feedback: Collect feedback through a form and save responses to a CSV file.

I tested the application with another person and added a feedback workflow so I can collect suggestions and improve the project based on real usage.

Why Does Open Innovation Matter?

Open innovation made it possible for me to build an AI-powered application without training a large model from scratch or relying entirely on a closed, hosted AI API.

Using open models and tools gives me more control over experimentation and makes it easier to understand how the different parts of my application work together.

Local inference also offers a path toward keeping gardening questions and other inputs on the user's computer when the relevant feature runs entirely locally. Some features, such as downloading models or accessing online resources, may still require an internet connection.

For me, open innovation means that an individual developer can take existing AI research and turn it into something practical, affordable to experiment with, and open to future improvements.

My Agent Session

I explored AI-assisted development tools while building and improving GreenBuddy AI.

I haven't included a saved DevRelay agent session link here because I don't yet have a verified session URL to share.

My First User

I tested GreenBuddy AI with another person and implemented a feedback form to collect suggestions. The feedback is saved locally in user_feedback.csv.

The tester suggested adding a new feature. This helped me recognize the importance of building around user needs instead of relying only on my own assumptions.

I'm reviewing the suggestion to decide which improvement to implement next.

There has been no confirmed payment from this test. My current goal is to validate the problem, improve the application, and understand whether it provides enough value for people to use regularly.

Prize Categories

I'll select the partner prize categories that match the challenge's official rules and the tools actually used in my project before publishing.

GreenBuddy AI

ABHINASH SAHOO — Fri, 09 Oct 2026 13:08:51 +0000

GreenBuddy AI 🌱 — Your Local Gardening Companion

🌿 What I Built

GreenBuddy AI is an AI-powered gardening assistant designed to help beginners identify plants, learn how to care for them, plan seasonal planting, and spend more time outdoors.

I built this project for the Hacktoberfest Open-Source AI Challenge — Week 1: Touch Grass.

✨ Features

🌱 Plant Identification: Upload a plant photo to get likely plant names and model confidence scores.
💧 Plant Care Assistant: Get AI-generated guidance for watering, sunlight, soil, and general plant care.

🪴 Planting Planner: Generate a planting plan based on your location, growing space, and selected period.
🌳 Outdoor Missions: Track simple gardening and outdoor activities to encourage spending more time with nature.
🤖 Local AI Assistant: Use a locally running language model through Ollama for gardening questions and suggestions.

🛠️ Tech Stack

Python and Flask
HTML, CSS, and JavaScript
Ollama with Qwen 2.5 3B
Hugging Face Transformers
PyTorch and Pillow

💡 Why Open-Source AI?

I wanted to explore how AI could support an everyday activity while keeping the project accessible and transparent.

GreenBuddy AI combines local language-model inference with image classification. Once the required models are downloaded, inference can run locally, reducing dependence on hosted AI APIs and helping keep plant photos and gardening questions on the user's device.

The application still needs Ollama and its models installed, and the plant-identification model must be downloaded before its first use. Some gardening recommendations may need verification for local climate and growing conditions.

🚀 Try the Project

GitHub repository: https://github.com/AMLAN-07/GreenBuddyAI

The project currently runs locally. Follow the setup instructions in the repository's README to install the dependencies and start the application.

🌱 What I Learned

Building GreenBuddy AI helped me explore how to connect a local language model to a Flask application, integrate an image-classification model, and create a frontend that brings multiple AI features together.

I also learned that AI-generated gardening advice should be treated as a starting point and checked against reliable, location-specific information.

🔮 What's Next?

Improve plant-identification accuracy and display clearer results.
Add weather-aware planting recommendations.
Improve gardening advice for different regions and seasons.
Add tests, documentation, and more beginner-friendly setup instructions.
Welcome contributions from the open-source community.

🤝 Contributions

Suggestions, bug reports, and contributions are welcome! Please visit the GitHub repository to explore the code and contribute.

🏆 Challenge

Built for Hacktoberfest 2026 — Week 1: Touch Grass.

Thanks for checking out GreenBuddy AI. Let's use AI to learn about plants, grow greener spaces, and reconnect with nature! 🌿

Building Kairos AI: My 10-Day Journey Building a Voice Coding Mentor with Murf Falcon & LiveKit

ABHINASH SAHOO — Sat, 15 Aug 2026 11:34:04 +0000

🔗 Project Repository
The complete source code for Kairos AI is available on GitHub:
https://github.com/AMLAN-07/murf-livekit-starter
Meet Kairos AI
Kairos AI handling a voice conversation with the user.

Specialist Agent Handoff
Kairos handing a DSA problem to the dedicated DSA Specialist Agent.

Call Analytics Dashboard
Kairos AI call analytics showing call outcomes.

LiveKit signal connection
↓
Timeout
↓
Tested network connectivity
↓
IPv6 connection failed
↓
IPv4 connection succeeded
↓
Adjusted network configuration
↓
LiveKit worked

Challenges Along the Way

"The project definitely didn't work perfectly on the first attempt."
LiveKit timeout → IPv6 investigation

Building Kairos was not always smooth. I faced issues with LiveKit connection timeouts, networking, agent handoffs, and tool integration. Debugging these problems helped me understand that building a voice agent requires not only good code, but also careful testing of real-time communication and system configuration.

What Didn't Go as Planned

Kairos was not built in one smooth run.

I had issues with LiveKit connectivity, IPv6 networking, agent handoffs, tool execution, and outbound calling. Some features worked in isolated tests but behaved differently when connected to the complete voice workflow.

Those problems were actually some of the most useful parts of the challenge. They taught me to debug the entire system instead of assuming every problem was caused by the Python code.

Building a voice agent is as much about debugging real-time systems as it is about writing prompts and integrating AI models.

The Problem I Wanted to Solve I wanted Kairos to provide a more natural interface: Talk → Think → Discuss → Practice
Meet Kairos AI Kairos can also communicate in English, Hindi, and Hinglish, allowing users to interact in a more natural way.
Murf Falcon — Giving Kairos a Voice tts=murf.TTS( voice="Samar", locale="en-IN", style="Conversational", tokenizer=tokenize.basic.SentenceTokenizer( min_sentence_len=2 ), text_pacing=True, )
Human Help / Escalation An AI mentor shouldn't pretend it can solve every situation.
Specialist Agent Handoff Instead of making Kairos an expert at everything, I created a separate specialist whose only responsibility is DSA.
Outbound Calling I also added an outbound-call capability.
Final Architecture After 10 days, Kairos evolved into something much more interesting than the simple voice agent I started with. ┌─────────────────┐ │ User │ └────────┬────────┘ │ Voice / Phone │ ▼ ┌─────────────────┐ │ LiveKit │ └────────┬────────┘ │ ▼ ┌─────────────────┐ │ Kairos AI │ │ Main Agent │ └───────┬─────────┘ │ ┌──────────────────┼──────────────────┐ │ │ │ ▼ ▼ ▼ Memory Tools DSA Specialist │ │ │ │ ┌───────┴──────┐ │ │ │ │ │ │ Codeforces Human Help │ │ │ │ │ └──────────┴───────┬──────┘ │ │ │ ▼ │ Analytics / Calls ◄────────┘ │ ▼ Murf Falcon TTS │ ▼ 🔊 User Conclusion

When I started this challenge, the goal was simply to build a voice agent.
Ten days later, I had built Kairos AI, a voice coding mentor with:

🎙️ Real-time voice interaction
🇮🇳 Indian English voice
🧠 Persistent memory
💻 Coding-problem tools
🛡️ Guardrails
🧑‍💻 Human escalation
📞 Outbound calling
📊 Call analytics
🤝 Specialist-agent handoffs
🌐 Multilingual interaction

The biggest takeaway for me is that voice AI is not just about making an LLM speak.
It's about designing an entire interaction system around the user.

And that's what made these 10 days so valuable.