DEV Community: Mahinur Rahman

Did you ever feel the need of money management but filling forms isn't making sense? Visit Accountant AI

Mahinur Rahman — Thu, 31 Jul 2025 19:49:13 +0000

What makes Accountant AI different than other expense tracker?

We reduced the need of ~~form fill-up~~. Just prompt us like - i have 3 subscription of netflix, vercel and gpt costing 20, 50 and 10 dollars and i have to pay them on the 5th of the month. Boom you will get 3 different recurring transaction with all the details -

Title
Description
Amount
Currency
Recurring or not
Due or not
Paid or not
Transaction date
Recurring date
Paid date
Even file link related to this transaction (if you convert Receipt Image, PDF or CSV)

Some powerful features:

File conversion: You can upload bank statement or receipt of your payment/income or maybe some random csv for your previous data you kept records - we can make them butter smooth by formatting in transactions!

2. AI Assistant: It knows all your transaction, just ask him anything you want! Even relevant files can be created by the assistant.

2. Transaction list: Even though your AI assistant knows everything you can just check manually from a table with high level filtering.

3. Projects: You can create projects based on your needs! For example, you are a small business owner, you can create a project with your store name and keep records of your products, buy-sell list here.

4. Statistics & Analytics: This one is very cool for showing calendar wise transaction data. You can navigate from months to month and click on the cell to check your daily income expense list. You also have some fancy useful graph where data can be exported too!

5. Due & Recurring: Here you will see all your due transaction and recurring transactions. You can get a summary of all your data + reminder for your any due or recurring transactions. Every month it will reset the recurring payment so that you don't need to update it again.

Interested? Give it a try... Accountant AI

🚀 Deploying Node.js Application with PM2, NGINX, and SSL Configuration 🚀

Mahinur Rahman — Mon, 07 Oct 2024 15:43:09 +0000

Today, I deployed a new Node.js app on AWS using a smooth setup process with Node.js, PM2, NGINX, and Certbot for SSL(no need to touch cpanel). Only 5 steps to deploy your app in AWS. Here’s the step-by-step guide that can save time for you!

Install Node.js & NPM:

sudo apt-get update
sudo apt-get install -y ca-certificates curl gnupg
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | sudo gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg
NODE_MAJOR=20
echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_$NODE_MAJOR.x $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/nodesource.list > /dev/null
sudo apt-get update
sudo apt-get install nodejs -y
sudo apt install npm -y
npm i -g n
sudo n lts

Clone Your Repo and Setup PM2:

git clone <your-repo>
cd <your-repo-directory>
git checkout <branch-name>
npm install
sudo npm i -g pm2@latest
pm2 init

Configure PM2 with a Template:

module.exports = {
  apps: [
    {
      name: 'your-app-name',
      cwd: '/home/ubuntu/my-project',
      script: 'npm',
      args: 'start',
      env: {
        "KEY": "value",
      },
    },
  ],
};

Make a subdomain first, then
Now add A record in your DNS - CPANEL for the public IP where your instance is live (example 3.107.76.239) and set TTL to 300

Configure NGINX for Reverse Proxy:

sudo apt install nginx
sudo nano /etc/nginx/sites-available/default

Set the domain and point your port in NGINX config:

server {
    listen 80;
    server_name yourdomain.com;
    location / {
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $host;
        proxy_pass http://127.0.0.1:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

Restart NGINX:

sudo systemctl restart nginx

SSL Configuration with Certbot (NO TOUCH NEEDED IN CPANEL):

sudo apt install certbot python3-certbot-nginx
sudo certbot --nginx -d yourdomain.com

Now you have your Node.js app running securely with an SSL-enabled domain 🎉
🔗 DM me if you'd like more tips on server setup, Node.js deployment, or other dev-related topics.

Nodejs #AWS #DevOps #PM2 #Nginx #SSL #FullStack #WebDev

The Power of AGGREGATION in Cron Jobs and Cost-Effectiveness

Mahinur Rahman — Mon, 23 Sep 2024 14:35:57 +0000

While working on my SaaS product I found, For 10k users, you'd need 10,001 queries daily with regular DB queries to reset credits or free prompt. With smart aggregation, you only need 2 queries, no matter if you have 10k or 100k users!

Firstly, let me give you some COST REVIEW for MongoDB production database (10k & 1 year):

Normal way, Daily Queries: 10,001
Annual Queries: 10,001 x 365 = 3,650,365 queries
Annual Cost: 3,650,365 x $0.001 = 3,650.37 USD

Aggregation way, Daily Queries: 2
Annual Queries: 2 x 365 = 730 queries
Annual Cost: 730 x $0.001 = 0.73 USD

Savings: 3,650.37 - 0.73 = 3,649.64 USD (nearly 4 lakh bdt)

Awesome, now look at traditional approach of query (which make one query for each user )

const resetLimitsForUsers = async () => {
  const users = await User.find({ /* conditions to select users */ });

  for (const user of users) {
    if (user.plan.remaining_prompt_count < 3 || user.plan.remaining_page_count < 3) {
      user.plan.remaining_prompt_count = 3;
      user.plan.total_prompt_count = 3;
      // Save updated plan
      await user.plan.save();
    }
  }
};

Here if you have 10,000 users, this results in 10,001 queries (1 for each user, plus the initial query to fetch users) - that was huge..

Now the hero entry, [ which looks little tough but it saves tons of your money ]

const resetPlanCounts = () => {
  cron.schedule('* * * * *', async () => {
    try {
      const twoMinutesAgo = new Date(Date.now() - 2 * 60 * 1000); // 2 minutes ago

      const usersWithRegisteredPlan = await User.aggregate([
        {
          $match: {
            createdAt: { $lte: twoMinutesAgo },
            plan: { $exists: true }
          }
        },
        {
          $lookup: {
            from: 'plans',
            localField: 'plan',
            foreignField: '_id',
            as: 'planDetails'
          }
        },
        {
          $unwind: '$planDetails'
        },
        {
          $match: {
            'planDetails.name': 'Registered',
            $or: [
              { 'planDetails.remaining_prompt_count': { $lt: 3 } },
              { 'planDetails.remaining_page_count': { $lt: 3 } }
            ]
          }
        },
        {
          $project: {
            planId: '$planDetails._id'
          }
        }
      ]);

      const planIds = usersWithRegisteredPlan.map(user => user.planId);

      if (planIds.length > 0) {
        const { modifiedCount } = await Plan.updateMany(
          { _id: { $in: planIds } },
          { $set: { remaining_prompt_count: 3, total_prompt_count: 3, remaining_page_count: 3, total_page_count: 3 } }
        );

        console.log(`${modifiedCount} plans reset for "Registered" users.`);
      } else {
        console.log('No plans to reset for today.');
      }
    } catch (error) {
      console.error('Error resetting plan counts:', error);
    }
  });
};

That's how you can run your cron job [ it runs automatically in a specific time ] for updating all 10k users credits or limit which can save more than 3600 USD in a year.

AUTHOR,
Name: Mahinur Rahman
Contact: dev.mahinur.rahman@gmail.com

My experience with OpenAI API

Mahinur Rahman — Sun, 24 Sep 2023 05:28:25 +0000

Today I’ll share my experience working with openAI API (ChatGPT)

✨ I have been working with AI based travel planner application✈️. I’m going to share my problem, what difficulties I’ve faced and how I came up with the solutions.

✨ Problem

Planning a trip based on users interests and other preferences where trip could be of multiple days.

✨How OPEN AI helped me:

I’ve connected OPEN AI with user preferences to get related places with their personality.

⭐️ Challenges ⭐️

Taking all user preferences to GPT to understand user’s personality.
Making prompt so that every time i get same response format.
Had to recover data returned from GPT in my preferred JSON format.
Connect google places API to get users required trip places based on GPT driven result.
Handling GPT error while generating a trip for smooth user experience.

⭐️ Solutions ⭐️

GPT has limited token supply for each prompt. We can’t pass all our data through prompt. It’s better to make another prompt to get desired data before making the final prompt. In our case we had to generate personality for each profiles by providing user preferences and interests to maintain token length small enough in final prompt.
POMPT Engineering is must for making application smooth. Application needs same response all the time. So making a prompt that gives same response all the time, is must. We had to repeat same keyword sometimes to make GPT understand what we need the most.
GPT generally replies like human being. But for developer like us who has a little more complex issues need the JSON format mostly. We need key-value pair in order to get out best. Cause parsing text and making JSON is not a good idea. We had specified our JSON format and current version of JSON to get the static output.
Now we have JSON, we need places. For getting places we made queries based on preferences of user and for each query we got some places from PLACES API.
Finally, the worst part of GPT is when traffic is high it breaks down. That’s a big issue until you start a project related to OPEN AI 😄 So all you need to check every time whether there is anything right or not. Making smooth user experience we had to handle them multiple times.

✨That’s all from my perspective. I believe learning knows no bounds. Feel free to share your thoughts 💭