DEV Community: Piyush Sahu

I Finally Revived My Healthcare Hackathon Project Using GitHub Copilot

Piyush Sahu — Sat, 23 May 2026 19:31:09 +0000

This is a submission for the "GitHub Finish-Up-A-Thon Challenge" (https://dev.to/challenges/github-2026-05-21)

I Finally Revived My Healthcare Hackathon Project Using GitHub Copilot

What I Built

I revived my unfinished healthcare hackathon project called Rakt-Daan.

Rakt-Daan is a platform designed to help connect:

blood donors,
volunteers,
and emergency blood requests

in a faster and more organized way.

The project originally started during a healthcare-focused hackathon where my team wanted to solve a real problem: people often struggle to quickly find blood donors during emergencies.

Like many hackathon projects, we built the prototype under time pressure with very limited sleep and lots of unfinished ideas.

After the hackathon ended, the project slowly became inactive.

The idea still felt meaningful to me, but the codebase was incomplete, several features were broken, and I never got time to properly polish it.

This challenge finally motivated me to reopen the repository and continue building it.

Demo

Project Features

Blood donor request system
Volunteer coordination workflow
Responsive frontend improvements
Firebase-based backend integration
Emergency request handling flow
Improved UI structure

Planned Future Features

AI-assisted donor matching
Multilingual support
Smart emergency notifications
Location-based recommendations

Screenshots / Demo

(Add your screenshots here)

GitHub Repository

(Add your GitHub repository link here)

Live Demo

(Add deployment link here if available)

The Comeback Story

When I reopened the project, it honestly looked like a typical unfinished student repository.

Some features were working, some were partially implemented, and some existed only as comments inside the code.

The biggest issues were:

unfinished authentication flow,
inconsistent backend structure,
UI responsiveness problems,
incomplete donor matching workflow,
and debugging issues across components.

The hardest part was not coding.

It was restarting.

Like many unfinished projects, I kept delaying it because I did not know where to begin fixing things.

This challenge helped me finally push through that mental barrier.

Instead of trying to rebuild everything at once, I started improving small parts step by step:

fixing frontend bugs,
restructuring components,
improving Firebase integration,
cleaning backend logic,
and optimizing workflows.

Slowly, the project started feeling alive again.

Now it feels much closer to a usable platform instead of just a hackathon prototype.

My Experience with GitHub Copilot

GitHub Copilot became surprisingly useful during the rebuilding process.

I mainly used it for:

debugging repetitive issues,
improving React components,
generating boilerplate code,
cleaning API logic,
and speeding up backend fixes.

What helped most was not just code generation.

It was reducing development friction.

Sometimes student projects stop progressing because small technical problems slowly kill momentum.

One unresolved bug or confusing function can delay progress for days.

Copilot helped me move through those smaller blockers much faster.

Instead of constantly switching between documentation and tutorials, I could stay focused on improving the actual project.

That made rebuilding feel smoother and less exhausting.

What I Learned

This experience taught me something important:

Most unfinished projects are not abandoned because the ideas are bad.

They are abandoned because momentum becomes difficult to maintain.

As students, we constantly balance:

academics,
hackathons,
internships,
events,
and new ideas.

Projects slowly get pushed aside.

Revisiting Rakt-Daan reminded me that unfinished projects still have value.

Sometimes they just need better tools, better experience, and a second attempt.

And honestly, finishing an old project feels far more satisfying than starting a new one.

Final Thoughts

This challenge pushed me to finally continue building something I genuinely cared about.

GitHub Copilot did not magically complete the project for me.

But it helped reduce the friction that often prevents developers from finishing what they started.

And I think that small difference matters a lot.

As an Engineering Student, Gemma 4 Changed How I Think About AI Development

Piyush Sahu — Sat, 23 May 2026 17:30:33 +0000

As an Engineering Student, Gemma 4 Changed How I Think About AI Development

As a chemical engineering student, I usually look at technology from a practical point of view.

Whenever I explore a new technology, one question always comes to my mind:

“Can this actually solve real-world problems, or is it just impressive in demos?”

That is why Gemma 4 genuinely interested me.

Most discussions around AI models focus on benchmarks, reasoning scores, and model sizes. But while reading about Gemma 4, I started thinking more about accessibility, deployment, and practical engineering applications.

For the first time, advanced AI models started feeling closer to real engineering systems instead of distant cloud technologies.

And honestly, that feels like a major shift.

What Stood Out to Me About Gemma 4

The most interesting thing about Gemma 4 is not only its capability.

It is the flexibility of deployment.

Google introduced different model variants designed for:

mobile devices,
local systems,
edge environments,
and larger compute infrastructure.

As an engineering student, this matters a lot because real-world systems are always limited by constraints:

power consumption,
hardware capability,
internet availability,
processing speed,
and cost.

A model that can adapt across different hardware conditions becomes much more useful for practical applications.

That is something I found genuinely exciting.

Why Local AI Feels Important

In engineering, systems become more reliable when they are less dependent on external conditions.

That is why local AI caught my attention while exploring Gemma 4.

Most AI applications today depend heavily on cloud infrastructure. But in many practical scenarios, local processing is more efficient and reliable:

healthcare systems in low-connectivity areas,
industrial monitoring,
emergency-response tools,
educational systems,
or smart environmental monitoring.

Recently, I have been exploring ideas related to healthcare innovation and water-quality analysis projects.

While learning about Gemma 4, I kept imagining how lightweight AI systems could support:

smart monitoring devices,
portable engineering systems,
AI-assisted data interpretation,
and offline technical support systems.

The possibility of combining edge AI with engineering applications feels extremely promising.

Open Models Are Important for Student Innovation

One thing I appreciate a lot about Gemma 4 is that it is open.

For students, open models create opportunities to actually learn by experimentation.

Most engineering students do not have access to expensive AI infrastructure.

But open systems allow us to:

test ideas,
study architectures,
build prototypes,
optimize workflows,
and experiment without major financial barriers.

I think this is very important for innovation culture among students.

Because many strong ideas fail before implementation simply due to lack of resources.

Engineering Is Slowly Entering the AI Era

One thing I realized while exploring Gemma 4 is that AI is no longer limited to software-only applications.

It is slowly becoming part of engineering systems themselves.

In the future, I think we will increasingly see AI integrated into:

process monitoring,
industrial safety,
smart manufacturing,
sustainability systems,
healthcare engineering,
and environmental analysis.

As someone studying engineering, this is probably the most exciting part for me.

The combination of engineering principles with accessible AI tools could create solutions that are both practical and scalable.

Why This Matters for Students Like Me

For many students, the biggest challenge is not creativity.

It is access.

Sometimes we have ideas but:

limited hardware,
limited funding,
or limited infrastructure.

That is why open and deployable AI models matter so much.

Tools like Gemma 4 reduce the gap between learning and building.

Instead of only reading about AI systems, students can now experiment with them directly.

And I think that changes how future engineers will learn and innovate.

Final Thoughts

Gemma 4 is technically impressive.

But for me, the bigger story is accessibility.

As an engineering student, what excites me most is not just “better AI.”

It is the possibility that students, researchers, and smaller innovators can now participate more actively in building real-world AI systems.

And honestly, I think that shift may become more important than the model itself.

"#gemma" "#googleai" "#opensource" "#ai" "#engineering"

Google I/O 2026 Made Me Realize Student Builders Can Now Compete With Startups

Piyush Sahu — Sat, 23 May 2026 14:57:03 +0000

When I started exploring AI development last year, building something impactful felt overwhelming.

As a student, there were always limitations:

limited infrastructure,
limited experience,
limited resources,
and sometimes even limited confidence.

But after watching Google I/O 2026, I realized something important:

The barrier between an idea and a working product is getting smaller than ever before.

This year’s announcements were not just about more powerful AI models.

They were about accessibility.

And for students, independent developers, and hackathon builders, that changes everything.

The Shift I Noticed at Google I/O 2026

Most discussions around Google I/O focused on Gemini updates, AI demos, and developer tools.

But the biggest takeaway for me was something deeper:

«AI development is becoming faster, simpler, and more accessible to smaller teams.»

Tools like:

Google AI Studio,
Firebase,
Gemini APIs,
Edge AI integrations,
and AI-assisted workflows

are reducing the amount of setup traditionally required to build products.

Earlier, students had to spend weeks configuring infrastructure before even starting innovation.

Now, much of that complexity is being abstracted away.

That means more time can be spent solving real problems.

Why This Felt Personal

I’m a chemical engineering student who actively participates in hackathons and student tech communities.

Recently, my team worked on a healthcare-focused project called Rakt-Daan, a platform designed to improve blood donor connectivity and emergency response coordination.

While watching Google I/O sessions, I kept imagining how much easier student-led innovation can become with the ecosystem Google is building.

Features that previously required large development teams are becoming accessible through integrated AI tooling:

AI chat support,
workflow automation,
smart recommendations,
real-time databases,
multilingual interaction,
and cloud-based deployment.

For student innovators, this is a massive shift.

Google AI Studio Was the Most Exciting Announcement for Me

Among all the announcements, Google AI Studio stood out the most.

Not because of flashy demos.

But because of how quickly developers can experiment.

The ability to rapidly prototype AI workflows, test prompts, and integrate intelligent systems dramatically reduces development friction.

For hackathons especially, speed matters.

A good idea alone is not enough anymore.

Execution speed decides whether a prototype becomes impactful or forgotten.

Google AI Studio feels like a tool designed for rapid experimentation, and that makes it extremely valuable for students and early-stage builders.

Firebase Quietly Solves One of the Biggest Problems

Another underrated part of the Google ecosystem is Firebase.

Many developers focus on AI models, but infrastructure complexity often becomes the real bottleneck.

Firebase simplifies:

authentication,
hosting,
cloud databases,
analytics,
notifications,
and backend integration.

That allows smaller teams to focus on building solutions rather than managing infrastructure.

For students trying to turn hackathon ideas into real products, this matters a lot.

AI Is Becoming Infrastructure

One thing became very clear throughout Google I/O 2026:

AI is no longer just a feature.

It is becoming part of the development infrastructure itself.

AI now assists with:

coding,
testing,
automation,
communication,
search,
and decision-making.

This changes how software will be built in the future.

More importantly, it changes who gets to build it.

Earlier, advanced experimentation was mostly limited to funded startups and large engineering teams.

Now, students with strong ideas can participate too.

What This Means for Students

As a student developer, Google I/O 2026 gave me something more valuable than excitement.

It gave me confidence.

Confidence that smaller teams can now build meaningful products faster than ever before.

Whether someone is building:

healthcare platforms,
sustainability tools,
education systems,
AI assistants,
or community-driven applications,

modern AI infrastructure is reducing the gap between imagination and execution.

And that may end up being the most important impact of Google I/O 2026.

Final Thoughts

The biggest lesson I took from Google I/O 2026 is simple:

«The future of innovation may belong to smaller, faster, and more experimental builders.»

And honestly, that future feels incredibly exciting for students.

Google didn’t just showcase better AI this year.

It showcased a future where more people can actually build with it.

My Experience with Defang: Exploring the Future of Safer Code

Piyush Sahu — Sat, 19 Jul 2025 10:08:49 +0000

This summer, I had the chance to explore an incredible developer tool that is changing how we think about secure and privacy-focused software development — it's called Defang.

As part of their campus ambassador program, I received some awesome swag (thank you, Defang! 🙌), but more importantly, I got hands-on experience with a tool that is built for modern-day developers, especially those concerned with open-source code safety, privacy, and collaboration.

🔍 What is Defang?
Defang is a secure-by-default platform for developers. Whether you're sharing API responses, writing debug logs, or collaborating with others, Defang helps you avoid leaking sensitive data by automatically cleaning or “defanging” content before it's stored or shared.

Key highlights:

✅ Automatic redaction of sensitive data (tokens, passwords, PII)

🔄 Easy integrations with GitHub, Slack, and more

🔐 Helps ensure compliance with privacy/security best practices