Building a product alone is lonely. There's no one to celebrate the small wins with. No one to share the anxiety when something breaks at 2 AM. No one to tell you whether the thing you're building is actually good or just feels good because you made it.

But I did it anyway. And last month, I launched Codeyst publicly.

This is the honest story of how it happened.

It Started With Frustration

I've been a freelance full-stack developer for years. In that time I've built dozens of products for founders — SaaS platforms, mobile apps, MVPs, internal tools. All kinds.

And I kept seeing the same pattern, over and over.

A founder would come to me with an idea. Excited. Energetic. Full of vision. We'd start the project and then spend the first week just setting things up — choosing a framework, configuring auth, standing up a database, writing boilerplate no one ever wants to write.

By the time we got to the actual product — the thing the founder was excited about — some of that energy was already gone.

I watched ideas lose momentum in setup.

And I felt it myself too. I had my own ideas. Side projects I'd start, get bogged down in configuration, and quietly abandon.

That frustration is where Codeyst was born.

The Idea Was Simple. The Execution Was Not.

The idea sounds obvious in hindsight:

What if you could just describe what you want to build — in plain language — and something would build it for you? Not generate a snippet. Not autocomplete a function. Actually build it. End to end. With a real database, real auth, real deployment.

Simple idea. But actually building it taught me how complex "simple" can be.

The first version was terrible. The AI would generate code that looked right but didn't run. Dependencies would clash. The database schema would be wrong. The generated components wouldn't connect to each other.

I scrapped it and started over.

The insight that changed everything was this: the AI shouldn't just generate code. It should work like an actual engineer.

An engineer doesn't just write code. They read the existing codebase first. They understand the context. They plan before they act. They check their work. They iterate.

So I rebuilt Codeyst around that model. Before writing a single line of code, it reads the project structure, understands what's already there, builds a step-by-step plan, and then executes precisely.

That's when it started actually working.

The Part Nobody Talks About

Building the AI was the fun part, honestly.

The hard part was everything else.

Payments. Auth. Credit systems. Deployment pipelines. Supabase integration. GitHub sync. Vercel API. Mobile support via Expo. Pricing pages. Terms and conditions. Privacy policies. Customer support flows. Documentation.

All of it, alone.

There were weeks where I questioned everything. Weeks where I'd see a competitor ship a new feature and feel behind. Weeks where I'd open my laptop and just stare at it.

But I kept coming back to the same thought: I've built too much to stop now.

So I didn't stop.

What Codeyst Actually Does

Let me be clear about what Codeyst is — because there are a lot of "AI app builders" out there and most of them are not what they claim.

Codeyst is not a frontend generator. It's not a code snippet tool. It's not a drag-and-drop builder with AI sprinkled on top.

It's a full-stack AI app builder that works like a real engineer.

You describe your app in plain language. Codeyst reasons about your requirements, plans the architecture, and builds it — complete with:

→ Real PostgreSQL database via Supabase → Authentication (sign up, login, sessions) → File storage → One-click deployment to Vercel → GitHub sync → Cross-platform mobile app development via Expo

Web and mobile. Both. From one conversation.

Every step happens in real time, visible to you. You watch the plan form, the files get created, the preview come alive. You can give feedback at any point and it adjusts.

When it's done, you have a real deployed product. Not a demo. Not a prototype. Something you can share a URL for right now.

Why Mobile Matters

Every other AI builder I know of is web-only.

But more than half the app ideas I heard from founders during my freelance years were mobile ideas. A fitness tracker. A social app. A delivery service. A marketplace. All mobile.

I always thought it was strange that no one in this space was solving for mobile.

So Codeyst does. Using Expo, we generate cross-platform iOS and Android apps from the same conversation you'd use to build a web app.

That's a real differentiator. And it came directly from listening to founders for years.

The Launch

I launched on Product Hunt in April 2026.

I had no marketing budget. No team. No PR firm. Just me, posting on my personal Twitter and LinkedIn, asking people to check out Codeyst.

It was terrifying in the best way.

The feedback was honest. Some people loved it. Some had questions. Some had feature requests I'd never thought of. All of it was valuable.

Building in public — being honest about where you are and where you're going — is something I've come to deeply believe in. Not every founder does it. I think more should.

What's Next

I'm just getting started.

There are features I want to build. Markets I want to reach. A company I want to grow.

I applied to Y Combinator for Summer 2026. Whether that works out or not, I'll keep building every day.

If you're a founder with an idea — try Codeyst free. No credit card required. You might be surprised how fast your idea becomes a real product.

If you're a developer who's felt the same frustration I felt — I built this for you too.

And if you're just someone who followed along this far — thank you. Genuinely.

Let's build something. 🚀

→ codeyst.app

In this comprehensive guide, we will delve into the intricacies of uploading and retrieving files in MongoDB GridFS, employing a streamlined approach through your Express server. Unlike the previous article, which showcased the utilization of the 'multer-gridfs-storage' npm package, we will now demonstrate an efficient method devoid of additional npm packages. Accompanying this process, we will also explore the retrieval of files from the GridFS bucket. The article is accompanied by a practical example and detailed steps to ensure a seamless implementation.

Step 1: Uploading Files to MongoDB GridFS

Before commencing the file upload process, ensure your primary Express server is fully configured and integrated with your MongoDB database.

1. Importing Dependencies: Initiate the process by importing essential dependencies such as Express, Mongoose, and Multer. The latter facilitates data parsing, while Mongoose establishes the connection with the MongoDB database.

import express from "express";
import mongoose from "mongoose";
import multer from "multer";
import { Readable } from 'stream';

const route = express.Router();
const upload = multer();

1. Creating the Upload API Route: Define a designated API route for uploading files to the GridFS storage.

route.post('/upload', upload.single('file'), async (req, res) => {
    try {
        const gridFsBucket = new mongoose.mongo.GridFSBucket(mongoose.connection.db);
        const uploadFile = gridFsBucket.openUploadStream(`${Date.now()}-${req?.file?.originalname}`, { contentType: req.file?.mimetype });
        const readableStream = new Readable();
        readableStream.push(req.file?.buffer);
        readableStream.push(null);
        readableStream.pipe(uploadFile);
        res.status(200).json({ message: 'success', success: true, filename: uploadFile.filename, id: uploadFile.id });
    } catch (error) {
        res.status(500).json({ message: error?.message, success: false });
    }
});

1. File Uploading Process Explanation: In this API route, Multer middleware facilitates the parsing of file data originating from the front end. Subsequently, a GridFS bucket instance is established, and an upload stream is initialized using the openUploadStream method. The file's content type is defined, and the data is piped into the MongoDB database through a readable stream. The response includes crucial details such as the filename and unique identifier of the uploaded file.

Step 2: Retrieving Files from MongoDB GridFS

To retrieve files from the GridFS storage, a dynamic GET route is implemented, requiring the filename as a parameter.

route.get('/:filename', async (req, res) => {
    try {
        const file = await mongoose.connection.db.collection('fs.files').findOne({ filename: req.params?.filename });
        const gridFsBucket = new mongoose.mongo.GridFSBucket(mongoose.connection.db);
        const stream = gridFsBucket.openDownloadStream(file?._id);
        res.set('Content-Type', file?.contentType);
        stream.pipe(res);
    } catch (error) {
        res.status(500).json({ message: error?.message, success: false });
    }
});

Conclusion: In this comprehensive guide, we have meticulously outlined a proficient approach to uploading and retrieving files in the MongoDB GridFS storage system using your Express server. Through a step-by-step breakdown of the process, we have elucidated the integration of essential dependencies, the creation of API routes, and the utilization of MongoDB's GridFSBucket for seamless file management. By adhering to these guidelines, you can establish a robust file management system within your Express application. If you encounter any challenges during implementation or wish to explore advanced concepts such as video streaming directly from the GridFS bucket, please feel free to engage with us through the comments section. Your inquiries and interests are valued and appreciated.

Click here

now let's set up our simple project in which we will learn how to upload files into the MongoDB database using the GridFs method.

for this, you must have installed node js in your local system, if not make sure you have installed it before getting further.

In this blog, we will explore how to upload files into MongoDB using the gridfs-storage package in combination with Node.js, Express, Multer, and Mongoose. GridFS is a specification for storing and retrieving large files (such as images, audio, video, etc.) in MongoDB.

Prerequisites

Before we begin, make sure you have the following tools and libraries installed:

1. Node.js and npm

2. Express.js

3. Mongoose

4. Multer

5. GridFS Storage

Step 1: Set Up the Project

Make a project directory, open it in any code editor and run this command into the terminal "npm init -y"

npm init -y

now after setting up your, you will be able to see a package.json file in your root directory.

now install these dependencies. by running this command.

npm install express mongoose multer gridfs-stream

Step 2: Create the Express Server

Create a file named app.js (or index.js) in your project directory and set up the basic Express server:

const express = require('express');
const mongoose = require('mongoose');
const multer = require('multer');
const app = express();
const port = process.env.PORT || 3000;
app.use(express.json());

const mongoURI = 'mongodb://localhost:27017/gridfs-file-upload';

const connectToMongoDB = async ()=>{
 try{
  await mongoose.connect(mongoURI)
  console.log('connected to database.')
 }catch(error){
  console.log(error)
 }
}
connectToMongoDB();

app.get('/', (req, res) => {
  res.json({ message: 'Welcome to GridFS File Upload!' });
});

app.listen(port, () => {
  console.log(`Server is running on port ${port}`);
});

Step 3: Configure Multer and GridFS Storage

import multer from 'multer'
import { GridFsStorage } from 'multer-gridfs-storage'

export const upload = multer({
    storage: new GridFsStorage({
        url: mongoURI ,
        file: (req, file) => {
            return {
                bucketName: "media",
                filename: `${Date.now()}.${file.originalname.split('.').pop()}`
            }
        }
    })
})

app.post('/upload', upload.single('file'), (req, res) => {
  if (!req.file) {
    return res.status(400).json({ message: 'No file uploaded' });
  }
  return res.json({ message: 'File uploaded successfully' });
});

Step 4: Run the Application

Start the Express server:

node app.js

by hitting the upload route with post API along with a file in the form of FornData you'll be able to upload the file into the MongoDB database, This setup allows you to upload files to MongoDB using the GridFS specification. You can further enhance this application by adding features such as file retrieval, deleting files, and more.

Feel free to explore more advanced features and customize the application according to your needs.

if you want to know how can we upload files without using 'multer-gridfs-storage', comments down and ill be wring the blog on that too. similarly, if you want to know how can we retrieve files from the GridFs Bucket, let me know in the comments.