DEV Community: Alpesh Borekar

My First Internship: Still Searching, Still Building

Alpesh Borekar — Thu, 25 Jun 2026 08:48:52 +0000

My First Internship: Still Searching, Still Building

There are days when I wonder if I'm doing something wrong.

Over the past year, I've spent thousands of hours trying to earn my first software engineering internship.

I didn't just apply through job portals.

I solved DSA problems.
Prepared for technical interviews.
Studied backend fundamentals.
Built projects.
Earned certifications.
Rewrote my resume countless times.
Recorded project walkthroughs.
Sent hundreds of cold emails.
Asked for referrals.
Applied to startups and large companies alike.

Some applications were rejected immediately.

Some never received a response.

A few reached the interview stage.

Those interviews taught me far more than any online course.

One interview changed how I looked at software engineering.

The interviewer liked my backend knowledge and asked about one of my projects. Then they asked a simple question:

"Do you have real users?"

I didn't.

I had built projects that worked.

But they were built for learning, not for people.

That question stayed with me for days.

Soon after, I took the AZ-900 certification exam.

I failed.

It wasn't because the exam was impossible.

I simply wasn't prepared enough.

Walking out after spending my own money and seeing the result was difficult.

For a while, I questioned whether I was good enough for this career at all.

But after a few days, I stopped thinking about the failure and started thinking about what I could improve.

Instead of jumping into another tutorial, I decided to finish something properly.

That project became CloudStash.

CloudStash isn't another CRUD application.

I wanted to understand how production-style backend systems actually work.

So I built a cloud file storage platform using:

Node.js + TypeScript
PostgreSQL
Redis
BullMQ workers
JWT authentication
Docker
Object storage
Background processing
Real-time upload progress

Ironically, writing the features wasn't the hardest part.

Deployment was.

Connecting multiple services, configuring Docker, fixing environment variables, debugging Redis connections, handling uploads in production, and making everything work together took much longer than I expected.

Eventually...

It finally went live.

I expected users.

Instead, almost nobody showed up.

At first, that felt like another failure.

Then I realized something important.

Building software and getting people to use software are two completely different skills.

Learning to code is only one part of the journey.

Learning distribution, usability, documentation, feedback, and trust is another challenge entirely.

I'm still looking for my first internship.

I still receive rejection emails.

I still get nervous before interviews.

But my goal has changed.

I'm no longer building projects only to fill my GitHub profile.

I'm trying to build software that solves real problems for real people.

Maybe CloudStash won't become the next Dropbox.

That's okay.

It has already taught me more about backend engineering than any tutorial ever could.

If you're also searching for your first internship, remember this:

Don't let rejection convince you that you're not improving.

Every interview reveals something you didn't know.

Every deployment teaches a lesson.

Every bug makes you a better engineer.

And eventually, one opportunity is all it takes.

I'm still waiting for that opportunity.

Until then...

I'll keep building.

I'll keep learning.

And I'll keep showing up.

I'd love to hear from other developers.

What helped you land your first internship or software engineering job?

Was it open source, networking, a side project, referrals, or something else?

Building CloudStash: A production-style cloud storage system with Node.js, PostgreSQL, Redis & BullMQ

Alpesh Borekar — Thu, 25 Jun 2026 08:30:49 +0000

Building CloudStash

Over the past few weeks I wanted to move beyond CRUD applications and understand how production-style backend systems are built.

That led me to build CloudStash, a cloud storage application focused on backend architecture rather than just file uploads.

Tech Stack

Node.js
TypeScript
PostgreSQL
Redis
BullMQ
Docker
React
Vite

Features

JWT Authentication
Secure file uploads & downloads
PostgreSQL metadata storage
Redis metadata caching
Background workers using BullMQ
WebSocket upload progress
Dockerized services
Hosted on Render + Vercel

What I learned

Building the features wasn't the hardest part.

The biggest challenges were:

connecting Redis, PostgreSQL and workers
deployment across multiple services
environment configuration
debugging production issues

This project helped me understand concepts that don't usually appear in small CRUD applications.

GitHub

https://github.com/alpeshborekar/cloudstash

Live Demo

https://cloudstash-frontend.vercel.app

I'd love to hear feedback from backend engineers.

What would you improve in this architecture?

How I Built CloudStash: A Cloud File Storage System with Node.js, PostgreSQL, Redis, and BullMQ

Alpesh Borekar — Tue, 23 Jun 2026 18:14:11 +0000

How I Built CloudStash

After several weeks of building and deployment debugging, I finally launched CloudStash, a cloud file storage application built to learn how production-style backend systems work beyond basic CRUD applications.

Why I Built It

Most tutorial projects stop after implementing CRUD APIs.

I wanted to understand how real systems handle:

File uploads
Background processing
Object storage
Caching
Authentication
Deployment
Real-time updates

CloudStash became my learning project for these concepts.

Tech Stack

Node.js
TypeScript
PostgreSQL
Redis
BullMQ
Docker
Render
Vercel

Features

JWT Authentication
File Uploads and Downloads
PostgreSQL Metadata Storage
Redis Caching Layer
Background Workers with BullMQ
Real-Time Upload Progress
Dockerized Deployment
Object Storage Support

Architecture

[Insert your architecture diagram here]

The system separates metadata from file storage and uses workers for background processing.

Biggest Challenges

The hardest part wasn't writing APIs.

It was:

Deployment issues
Environment variables
Connecting multiple services together
Handling production configuration

I spent more time debugging deployment than writing features.

What I Learned

Redis is useful beyond caching
Background jobs simplify heavy processing
Separating metadata from blobs improves design
Production deployments are very different from local development

What's Next

Planned improvements:

File sharing links
Folder support
Storage analytics
Multipart uploads
Better monitoring

Links

Demo:
https://cloudstash-frontend.vercel.app

GitHub:
https://github.com/alpeshborekar/cloudstash