Forem: Arham Rumi

Building a Production Server from Scratch: The Ultimate Guide

Arham Rumi — Fri, 10 Oct 2025 20:57:35 +0000

Deploy like a pro — set up, secure, and scale your own production-ready VPS with zero DevOps experience.

This article is originally published at my Medium account.
Read this article on Medium

In a world obsessed with managed services and serverless stacks, understanding how to manage your own Virtual Private Server (VPS) is a timeless skill.

Running your own server gives you:

✅ Full control over your infrastructure
✅ Lower long-term costs compared to managed platforms
✅ Real DevOps insight that translates across all cloud providers

Whether you’re launching a startup MVP, a SaaS app, or your personal project, this guide will take you from a blank VPS to a fully deployed, production-grade environment.

💡 Note: This guide doesn’t focus on any specific cloud provider — the steps are exactly the same no matter where you host your VPS. You can go with AWS EC2, DigitalOcean, Vultr, Linode, or any other provider that fits your budget, region, or performance needs.

I’ll dive deeper into comparing different VPS providers in a future article, but for now, let’s stay focused on setting up your server the right way.

Initial Server Access

First, connect to your VPS using SSH or the built-in web terminal provided by your hosting service. In this guide, I’ll be using the provider’s integrated web terminal to connect to my VPS.

You will see the integrated terminal of your VPS like this after connecting successfully.

Check System Codename

Run this command to see the codename of your VPS OS.

lsb_release -a

You will see something like this.

My VPS codename is noble.

Identifying System’s Init System

Before managing services like MongoDB or Node.js applications, it’s important to know which init system your Linux distribution uses. The init system is responsible for starting and managing processes after the system boots.

Run the following command to identify your init system:

ps --no-headers -o comm 1

It will display your init system. Mine is systemd.

💡 Why It Matters:
Service management commands (like starting, stopping, and enabling MongoDB or PM2) depend on the init system. Most VPS providers today use systemd, so if your output shows systemd, you can safely follow all systemctl commands in this guide.

Update System Packages

Always update a fresh VPS — this closes known vulnerabilities in the base image. Run these commands:

sudo apt update && sudo apt upgrade -y

sudo apt autoremove -y

Install Essentials

These tools are vital for fetching remote files and deploying your app.

sudo apt install curl git -y

Install Core Runtime — Node.js (LTS Version)

Go to https://deb.nodesource.com/ to get the latest LTS (Long Term Support) version.

Run the following commands one by one.

curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -

sudo apt install -y nodejs

You might have noticed that our command includes an extra -E flag compared to the official NodeSource installation command.

Normally, when you use sudo, your environment variables — like proxy settings (HTTP_PROXY, HTTPS_PROXY, etc.) or custom configuration paths — are not passed to the root environment. This is a security measure to prevent unexpected privilege escalation through environment manipulation.

By using sudo -E, we ensure that your existing environment (especially proxy-related settings) stays intact during the installation.

✅ If you’re behind a proxy, using -E prevents download failures caused by missing proxy configurations.

✅ If you’re on a direct internet connection, it doesn’t hurt — the command works the same as sudo.

🧠 In short: sudo -E is just a safety net. You can omit it if your VPS has direct internet access, but it’s good practice to include it to avoid proxy-related issues during installations.

Verify Installation

Run these commands to verify your runtime installations.

node -v
npm -v

⚙️ Why LTS? LTS releases are battle-tested and receive security updates for years — perfect for production stability.

Install MongoDB

Modern applications need modern databases. Here’s how to install MongoDB Community Edition. This includes several steps, which we’ll go through one by one with short descriptions for better understanding.

First, make sure you have GnuPG installed.

sudo apt install gnupg -y

Now, the actual installation will start. I’ll follow the official instructions mentioned at this link. You can follow the link directly if you prefer, or stay here — I’ll walk you through each necessary step.

Liquid error: internal

Import the Public Key

Run this command to import the official keys.

curl -fsSL https://www.mongodb.org/static/pgp/server-8.0.asc | sudo gpg -o /usr/share/keyrings/mongodb-server-8.0.gpg --dearmor

Create the List File

You need to run only one of these commands according to your VPS codename. My VPS codename is noble.

For noble run this:

echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-8.0.gpg ] https://repo.mongodb.org/apt/ubuntu noble/mongodb-org/8.2 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-8.2.list

For jammy run this:

echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-8.0.gpg ] https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/8.2 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-8.2.list

For focal run this:

echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-8.0.gpg ] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/8.2 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-8.2.list

Reload the Package Database

Run the following command to reload the package database.

sudo apt update

Install MongoDB Community Server

Install the latest stable version of MongoDB using the command:

sudo apt install -y mongodb-org

Start MongoDB

You can start the mongod process by issuing the following command according to your init system. if you have an older init system, follow this link:

Liquid error: internal

My init system is systemd, so I will use the following commands:

sudo systemctl start mongod

If you receive an error similar to the following when starting mongod:

Failed to start mongod.service: Unit mongod.service not found.

Run the following command first:

sudo systemctl daemon-reload

Then run the start command above again.

Check MongoDB Status

Run this command to verify MongoDB is actually running.

sudo systemctl status mongod

Then press CTRL + C to exit MongoDB status view and return to the normal terminal.

🔒 Pro Tip: Enabling MongoDB ensures it restarts automatically after reboots.

sudo systemctl enable mongod

Restart MongoDB

You can restart the mongod process by issuing the following command:

sudo systemctl restart mongod

Application Deployment

Pull Your Code

I have a public repository for learning purposes. You can also check it out, star it, or fork it if you’d like to start from there. Since it’s public, I don’t need to set up SSH to clone it.

git clone https://github.com/arham-rumi/social-app.git

Move inside the repository using:

cd social-app

🔒 Pro Tip: Never ever public your code unless you actually want to make it OpenSource.

Setup Environment

Install packages using:

npm install

Create .env file using nano utility. Please make sure you use the same filename for environment variables as the one imported in your code. For now, my code imports the environment variables from .env, so I’ll create the file with the same name like this:

nano .env

You’ll enter the editor mode. Simply copy all the variables that you’ve defined in your local .env file, like this:

Now, press CTRL + O to write out changes. It will ask you to confirm. Press ENTER.

It will then show you the number of written lines as confirmation that your file has been saved.

Then move out of the editor using CTRL + X.

Production Process Management

Install PM2 globally using:

sudo npm install -g pm2

🚀 Why PM2? It ensures zero-downtime restarts, load balancing, and monitoring — ideal for production-grade stability.

Run our app’s process:

pm2 start npm --name "social-app-prod" -- run start

Here, the word start after run refers to the script name defined in your package.json file. You can replace the name with yours. Now it will look like this.

Monitor your application using:

pm2 logs social-app-prod

Here, social-app-prod is the name of the process — change it if you’re using a different name. It will show the logs like this:

You can exit the logs using CTRL + C. Check the status of your processes using:

pm2 list

Or by using:

pm2 status

It will show your processes.

Ensure your application survives server restarts using these commands:

pm2 save

pm2 startup systemd

Validation & Testing

Health Check Verification

Test your application internally:

curl http://127.0.0.1:7000/api/v1/healthcheck

External Access Testing

Access your application via the server’s public IP. I am using postman.

That’s great — your server is working properly!

🌐 Network Configuration: If inaccessible, configure your cloud provider’s firewall rules to allow TCP traffic on your application port. For example:

There may be other ports or rules you’ll need to configure. However, for this article, I’ve kept it as simple as possible for demonstration purposes.

Outro: From Command Line to Confidence

You’ve just built more than a server — you’ve built independence. By setting up and securing your own VPS from scratch, you’ve gained control over your infrastructure and the confidence to deploy applications like a pro.

You now know how to:
✅ Secure your server with updates and best practices
✅ Install Node.js and MongoDB the professional way
✅ Deploy and manage production apps with PM2
✅ Keep everything running through reboots and scaling demands

Your VPS is now your personal cloud — custom, optimized, and truly yours. Every configuration command you’ve run is a building block toward mastering modern DevOps and backend scalability.

Next Steps

In the next guides, we’ll take this setup even further — configuring Nginx as a reverse proxy, enabling free SSL certificates with Let’s Encrypt, and automating secure backups to ensure your application is not just live, but resilient.

🚀 Own your stack. Master your craft. Deploy with confidence.

From here, explore containerization with Docker, implement CI/CD pipelines, or add monitoring — but remember: every enterprise-scale application starts with the solid foundation you just built.

💪 You didn’t just deploy an app — you built the foundation for scalable, self-managed infrastructure.

Adding Version Information to a PyInstaller Onefile Executable

Arham Rumi — Fri, 23 May 2025 21:17:06 +0000

If you’ve ever created a standalone Windows executable using PyInstaller, you might have noticed that your .exe file lacks version details like File Description, Product Name, or Company Info. While it works perfectly fine, it looks unpolished and unbranded — especially if you’re shipping your app to clients or distributing it publicly.

In this article, you’ll learn how to embed version information into your one-file executable built with PyInstaller. This is a small detail that goes a long way in giving your app a professional edge.

Why Add Version Info to Your EXE?

When a user right-clicks your .exe and selects Properties → Details, Windows shows metadata like:

This same metadata also appears as a small tool-tip when the user hovers over the .exe file in File Explorer, giving your application a polished and professional touch.

Note: In this guide, we’ll focus specifically on adding version information to a one-file executable. If you’re not familiar with creating an .exe file using PyInstaller, be sure to check out the following guide first to get started.

Build a One-File EXE with PyInstaller (Including Binaries & Resources)

Arham Rumi
Arham Rumi

Arham Rumi

Follow

May 18 '25

Build a One-File EXE with PyInstaller (Including Binaries & Resources)

#python #pyinstaller #tutorial #uv

3 reactions
Comments Add Comment

4 min read

Prerequisites

Before we dive in, make sure you have the following:

Python installed
PyInstaller installed (Run pip install pyinstaller if you haven’t already)
Your main Python script ready

But What Does the Version File Look Like?

At this point, you might be wondering:
“Okay, I can add a version info file… but what exactly does that file look like? Is it just plain text? Does it involve some kind of programming language?”

Great questions!

Let’s start by looking at a real-world example — a Windows .exe that already contains version information. This will give us a clear idea of what the version file should look like.

Extracting Version Info from `cmd.exe`

We’ll use PyInstaller’s handy tool pyi-grab_version to extract version information from a well-known Windows executable like cmd.exe. Run the following command in your terminal or by opening cmd window:

pyi-grab_version C:\Windows\System32\cmd.exe

This will generate a file_version_info.txt file containing all the embedded metadata. The file will be saved in your current working directory (where the terminal or command prompt was opened).

So in my case, the generated version info file — file_version_info.txt — was saved to:

C:\Users\RUMI

with the following content.

# UTF-8
#
# For more details about fixed file info 'ffi' see:
# http://msdn.microsoft.com/en-us/library/ms646997.aspx
VSVersionInfo(
  ffi=FixedFileInfo(
    # filevers and prodvers should be always a tuple with four items: (1, 2, 3, 4)
    # Set not needed items to zero 0.
    filevers=(10, 0, 19041, 4355),
    prodvers=(10, 0, 19041, 4355),
    # Contains a bitmask that specifies the valid bits 'flags'r
    mask=0x3f,
    # Contains a bitmask that specifies the Boolean attributes of the file.
    flags=0x0,
    # The operating system for which this file was designed.
    # 0x4 - NT and there is no need to change it.
    OS=0x40004,
    # The general type of file.
    # 0x1 - the file is an application.
    fileType=0x1,
    # The function of the file.
    # 0x0 - the function is not defined for this fileType
    subtype=0x0,
    # Creation date and time stamp.
    date=(0, 0)
    ),
  kids=[
    StringFileInfo(
      [
      StringTable(
        '040904B0',
        [StringStruct('CompanyName', 'Microsoft Corporation'),
        StringStruct('FileDescription', 'Windows Command Processor'),
        StringStruct('FileVersion', '10.0.19041.4355 (WinBuild.160101.0800)'),
        StringStruct('InternalName', 'cmd'),
        StringStruct('LegalCopyright', '© Microsoft Corporation. All rights reserved.'),
        StringStruct('OriginalFilename', 'Cmd.Exe'),
        StringStruct('ProductName', 'Microsoft® Windows® Operating System'),
        StringStruct('ProductVersion', '10.0.19041.4355')])
      ]), 
    VarFileInfo([VarStruct('Translation', [1033, 1200])])
  ]
)

This is the version file we’ll use (and modify) to embed metadata into our own Python .exe. As you can see, it’s not too difficult to understand — many fields are self-explanatory, and some even come with helpful comments.

Good news: you don’t need to fill out or modify every single field.
Being a smart developer, we’ll take the generated file_version_info.txt, copy it, and then customize only the parts that matter for our app.

Adding Version Info to Our App

Let’s say our application is called unify.exe. At this point, your folder structure might look like this:

So, we have added version.txt file with the following content:

# UTF-8
#
# For more details about fixed file info 'ffi' see:
# http://msdn.microsoft.com/en-us/library/ms646997.aspx
VSVersionInfo(
  ffi=FixedFileInfo(
    # filevers and prodvers should be always a tuple with four items: (1, 2, 3, 4)
    # Set not needed items to zero 0.
    filevers=(1, 0, 0, 0),
    prodvers=(1, 0, 0, 0),
    # Contains a bitmask that specifies the valid bits 'flags'r
    mask=0x3f,
    # Contains a bitmask that specifies the Boolean attributes of the file.
    flags=0x0,
    # The operating system for which this file was designed.
    # 0x4 - NT and there is no need to change it.
    OS=0x40004,
    # The general type of file.
    # 0x1 - the file is an application.
    fileType=0x1,
    # The function of the file.
    # 0x0 - the function is not defined for this fileType
    subtype=0x0,
    # Creation date and time stamp.
    date=(0, 0)
    ),
  kids=[
    StringFileInfo(
      [
      StringTable(
        '040904B0',
        [StringStruct('CompanyName', 'Rumi Softs'),
        StringStruct('FileDescription', 'A small tool to combine video clips.'),
        StringStruct('FileVersion', '1.0.0.0'),
        StringStruct('InternalName', 'unify'),
        StringStruct('LegalCopyright', 'Rumi Softs. All rights reserved.'),
        StringStruct('OriginalFilename', 'unify.exe'),
        StringStruct('ProductName', 'Unify'),
        StringStruct('ProductVersion', '1.0.0.0')])
      ]), 
    VarFileInfo([VarStruct('Translation', [1033, 1200])])
  ]
)

Linking the Version File

Now that we have our version.txt file ready with the necessary content, it’s time to update our existing unify.spec file to link it. Here’s the updated unify.spec file:

# -*- mode: python ; coding: utf-8 -*-


a = Analysis(
    ['main.py'],
    pathex=["E:\\unify\\.venv\\Lib\\site-packages"],
    binaries=[('E:\\unify\\ffmpeg_build\\bin\\ffmpeg.exe','bin'), ('E:\\unify\\ffmpeg_build\\bin\\ffprobe.exe','bin')],
    datas=[],
    hiddenimports=["easygui","tqdm"],
    hookspath=[],
    hooksconfig={},
    runtime_hooks=[],
    excludes=[],
    noarchive=False,
    optimize=0,
)
pyz = PYZ(a.pure)

exe = EXE(
    pyz,
    a.scripts,
    a.binaries,
    a.datas,
    [],
    name='unify',
    debug=False,
    bootloader_ignore_signals=False,
    strip=False,
    upx=True,
    upx_exclude=[],
    runtime_tmpdir=None,
    console=True,
    disable_windowed_traceback=False,
    argv_emulation=False,
    target_arch=None,
    codesign_identity=None,
    entitlements_file=None,
    icon=['favicon.ico'],
    version='version.txt'
)

The only change we made is adding the version file path at the end of the exe tuple — nothing else was modified.

Building the Executable

With everything set, let’s build the .exe!

Before doing that, it’s a good idea to clean up the previous build just to avoid any unexpected conflicts. So go ahead and delete the existing build/ and dist/ folders.

Now, open your terminal in the project root (where main.py resides), and run:

pyinstaller unify.spec

After a successful build, you’ll see freshly created build/ and dist/ directories.

Navigate to the dist/ folder and locate your unify.exe.
Right-click on it → Properties → Details, and you’ll now see the version info and metadata you've added.

Conclusions

Adding version info might seem minor, but it’s one of those professional touches that elevate your app — especially in production environments or when sharing with non-technical users.

With just a few extra lines and a version file, your app transforms from “just another Python script” into a well-branded, traceable, and polished product.

Let’s Hear From You!

If you found this guide helpful, don’t forget to _share _it with fellow developers who might benefit too!

Have questions, suggestions, or ran into any _issues _while adding version info to your .exe?
👇 Drop a comment below — I’d love to hear your thoughts and help you out.

Your feedback not only helps improve the content, but also supports others in the community facing the same challenges.

Thanks for reading, and happy coding! 🚀

Build a One-File EXE with PyInstaller (Including Binaries & Resources)

Arham Rumi — Sun, 18 May 2025 18:48:53 +0000

Packaging Python projects into standalone executables can be incredibly useful for sharing your work with non-developers. In this guide, we'll walk through how to convert your Python script — even one that depends on additional binaries like ffmpeg or modules like easygui — into a single .exe file using PyInstaller. Let’s have a look at the project structure.

Let’s have a quick overview of this project.

.venv: The virtual environment that keeps your project isolated and independent.
ffmpeg_build: Contains the ffmpeg binaries used in the project. You might not need this specific folder if you’re using other binaries, but the concept of including external binaries remains the same.
favicon.ico: The icon file for your application.
main.py: The main script containing all the core logic of your application.
pyproject.toml: Project configuration file created by uv, specifying dependencies and metadata.

In this guide, we’re using uv as the package and project manager. It automatically generates some boilerplate files during initialization. Don’t worry if you’re using a different virtual environment or package manager — the steps in this guide still apply.

Now, let’s move on to the core of the guide. Here’s what we’ll need:

PyInstaller
.spec file
Manual updates to the .spec file to correctly handle paths and packages

We’ll begin by generating a basic .spec file using PyInstaller. Then, we’ll manually edit it to suit our project’s structure and rebuild the package using the updated .spec file. That’s the overall process.

Step 1: Install PyInstaller
Run the following command in your terminal or command prompt:

pip install pyinstaller

To confirm that PyInstaller was installed successfully, run the following command in a new command prompt:

pyinstaller -v

If it returns the version number, congratulations — PyInstaller is installed correctly. If not, review the error message and resolve the issue accordingly. You can comment the issue and I will respond to it.

Step 2: Creating .spec file

Navigate to the root folder of your project (where your main script is located), and run the following command:

pyinstaller --onefile --name "unify" main.py

Let’s break down the command:

--onefile: Tells PyInstaller to bundle everything into a single .exe file
--name: Specifies the desired name for both the output .exe and the generated .spec file
main.py: This is the entry point of your application—the script containing your project’s logic

After running the command, PyInstaller will execute and display logs ending with something like:

You should now see new folders like build/, dist/, and a unify.spec file in your project directory. These are generated automatically by PyInstaller after the initial build.

Among these, the unify.spec file is the most important for us—it defines how PyInstaller bundles your application. At this point, it contains the default configuration, which we will now customize to properly include paths, external binaries, and required packages.

The unify.spec file contains this:

# -*- mode: python ; coding: utf-8 -*-


a = Analysis(
    ['main.py'],
    pathex=[],
    binaries=[],
    datas=[],
    hiddenimports=[],
    hookspath=[],
    hooksconfig={},
    runtime_hooks=[],
    excludes=[],
    noarchive=False,
    optimize=0,
)
pyz = PYZ(a.pure)

exe = EXE(
    pyz,
    a.scripts,
    a.binaries,
    a.datas,
    [],
    name='unify',
    debug=False,
    bootloader_ignore_signals=False,
    strip=False,
    upx=True,
    upx_exclude=[],
    runtime_tmpdir=None,
    console=True,
    disable_windowed_traceback=False,
    argv_emulation=False,
    target_arch=None,
    codesign_identity=None,
    entitlements_file=None,
)

This is the basic .spec file and we will update it.

Step 3: Updating the .spec File for Paths and Packages

Let’s edit the .spec file to tell PyInstaller exactly what it needs to include for your application to work correctly in a single .exe file.

# -*- mode: python ; coding: utf-8 -*-


a = Analysis(
    ['main.py'],
    pathex=["E:\\unify\\.venv\\Lib\\site-packages"],
    binaries=[('E:\\unify\\ffmpeg_build\\bin\\ffmpeg.exe','bin'), ('E:\\unify\\ffmpeg_build\\bin\\ffprobe.exe','bin')],
    datas=[],
    hiddenimports=["easygui","tqdm"],
    hookspath=[],
    hooksconfig={},
    runtime_hooks=[],
    excludes=[],
    noarchive=False,
    optimize=0,
)
pyz = PYZ(a.pure)

exe = EXE(
    pyz,
    a.scripts,
    a.binaries,
    a.datas,
    [],
    name='unify',
    debug=False,
    bootloader_ignore_signals=False,
    strip=False,
    upx=True,
    upx_exclude=[],
    runtime_tmpdir=None,
    console=True,
    disable_windowed_traceback=False,
    argv_emulation=False,
    target_arch=None,
    codesign_identity=None,
    entitlements_file=None,
    icon=['favicon.ico'],
)

Here, you’ll notice we’ve updated several key variables in the .spec file:

pathex: Specifies additional paths to search for imports.
binaries: Points to external binary files (e.g., ffmpeg.exe, ffprobe.exe) that need to be bundled with your application.
hiddenimports: Lists any modules that are dynamically imported in your code but may not be automatically detected by PyInstaller. Adding them here helps avoid _ModuleNotFoundError _at runtime.
icon: Path to your .ico file. In many cases, a relative path will work fine. However, if you encounter an error or your .exe file doesn’t show the icon as expected, try using the full absolute path. On Windows, note that icon updates may not be immediately visible due to icon caching behavior.

Note: All these options can also be provided as flags when running the pyinstaller command. However, we kept the initial command simple because you’ll likely need to tweak the .spec file manually anyway—even if you pass all options up front.

Now, delete the build/ and dist/ directories to clean up the old build, and run this command:

pyinstaller unify.spec

The build process will take some time to complete. During this, you’ll see logs detailing the packaging steps.

Once finished, navigate to the dist/ directory — you’ll find your one-file .exe there, complete with the custom icon (if everything was set correctly). It should look something like this:

🎉 That’s it! Your project is now bundled into a single executable.

If you run into any issues, feel free to drop a comment — I’ll do my best to help you troubleshoot and resolve them.

Running Puppeteer on a Server: A Complete Tutorial

Arham Rumi — Fri, 20 Dec 2024 18:17:10 +0000

Puppeteer is a Node.js library that provides a high-level API to control Chrome or Chromium browsers over the DevTools Protocol. It's a powerful tool for web scraping, automated testing, capturing screenshots etc. While using Puppeteer locally is straightforward, running it on a server requires additional considerations. This guide will walk you through the steps to get Puppeteer up and running on a server.

Preparing Server for Puppeteer

Update Server

This step is crucial for the successful execution of Puppeteer. Execute the following commands.

sudo apt update -y
sudo apt upgrade -y

Install Dependencies

Install the following dependencies to ensure Puppeteer runs smoothly.

sudo apt-get install libpangocairo-1.0-0 libx11-xcb1 libxcomposite1 libxcursor1 libxdamage1 libxi6 libxtst6 libnss3 libcups2 libxss1 libxrandr2 libatk1.0-0 libgtk-3-0 libasound2t64 libgbm-dev

Install Puppeteer

Execute the following command to install the latest version of Puppeteer, which is always recommended for optimal performance.

npm i puppeteer

Using Puppeteer

You can use the following code snippet to verify that Puppeteer is functioning correctly by invoking this function at your desired route.

const puppeteer = require("puppeteer");

/**
 * Launches a Puppeteer browser, navigates to a webpage, and then closes the browser.
 *
 * Launch Options:
 * - headless: Run the browser in headless mode (no GUI).
 * - args:
 *   - "--no-sandbox": Required if running as the root user.
 *   - "--disable-setuid-sandbox": Optional, try if you encounter sandbox errors.
 */

const runPuppeteer = async () => {
  try {
    // Launch a Puppeteer browser instance with custom arguments
    const browser = await puppeteer.launch({
      headless: true,
      args: [
        "--no-sandbox",
        "--disable-setuid-sandbox",
      ],
    });

    // Open a new page in the browser
    const page = await browser.newPage();

    // Navigate to the specified URL
    await page.goto("https://www.google.com");

    console.log("Navigation to Google completed.");

    // Close the browser
    await browser.close();
    console.log("Browser closed successfully.");
  } catch (error) {
    console.error("An error occurred:", error);
  }
};

// Execute the function
runPuppeteer();

Conclusion

Running Puppeteer on a server requires careful setup to handle dependencies, permissions, and resources. By following this guide, you can effectively deploy Puppeteer for tasks such as web scraping or automated testing in a server environment. For more advanced use cases, consider using tools like PM2 for process management and Docker for containerization.

Feel free to share this guide with others, and let us know in the comments if you encounter any issues after following the instructions.

Installing Node.js on Windows: A Complete Tutorial

Arham Rumi — Sun, 20 Oct 2024 14:16:52 +0000

Node.js, a powerful JavaScript runtime built on Chrome's V8 engine, is a popular choice for developing scalable and high-performance web applications. Whether you're a front-end developer looking to expand your skills or a back-end developer diving into server-side JavaScript, setting up Node.js is the first step. This guide will walk you through the process of installing Node.js on your Windows machine, ensuring a smooth setup for your development environment. By the end of this tutorial, you’ll be ready to start building and running Node.js applications with ease.

Installing Node.js

Follow these steps to successfully install Node.js on Windows.

1 - Download Node.js
Download the LTS (Long Term Support) version of Node.js by clicking the "Download Node.js (LTS)" button on the homepage at https://nodejs.org/en. Alternatively, if you prefer to download a different version, you can visit https://nodejs.org/en/download/prebuilt-installer.

2 - Installing Node.js
Now, let's proceed with installing Node.js. Be sure to follow each step closely to stay in sync.

Locate the downloaded file and double-click it to launch the installer. If a security prompt appears, confirm to proceed. You will then see the following screen; click "Next":

Accept the License Agreement by checking the box, then click "Next."

Select the destination folder for the installation. It's recommended to leave the default location as is, then click "Next."

Select the features you want to install. It’s recommended to keep the default selection, then click "Next."

I recommend checking the box for "Automatically install the necessary tools." Otherwise, you will need to set them up manually. Let the setup handle it for you, then click "Next."

Click "Install" to begin the installation process.

Click "Finish" to proceed to the next step.

Read the prompt and press any key, such as "Enter," to proceed to the next step.

Read the prompt and press any key, such as "Enter," to proceed to the next step. This will initiate the download and installation of the required tools.

The following screen will appear once the tool installation is complete. Press "Enter" to finish the process, and be sure to restart your system.

Congratulations! You have successfully installed Node.js on your Windows machine. With Node.js set up, you can now start building and running JavaScript applications efficiently. Whether you're developing server-side applications, creating RESTful APIs, or exploring the world of full-stack development, Node.js opens up a realm of possibilities.

If you encounter any issues during the installation or have questions about getting started with Node.js, feel free to leave a comment below. Don’t forget to share this guide with others. Happy coding!

MongoDB Installation on Windows: Your 2024 Guide

Arham Rumi — Mon, 14 Oct 2024 11:47:36 +0000

MongoDB, known for its flexible schema design and robust scalability, is a popular choice for developers and database administrators working on modern web and mobile applications. Setting up MongoDB on a Windows machine involves two main components: the MongoDB Server, which handles data storage, and MongoDB Compass, a graphical user interface for managing databases. This step-by-step guide will walk you through the complete installation process, ensuring a smooth setup for your development environment. Follow these steps carefully to avoid any errors during the installation.

Installing MongoDB Server

MongoDB Server is a robust back-end solution for storing and managing your data efficiently.

1 - Download MongoDB Server

Download the latest version of MongoDB Server by following these steps:

Visit the MongoDB Download Center and scroll down to find "MongoDB Community Server" under the "MongoDB Community Edition" section. Alternatively, you can go directly to the MongoDB Community Server download page by clicking on this official link: https://www.mongodb.com/try/download/community
Scroll down slightly to find the "Download" button. Ensure that you have selected the same options (your version may be the latest one) as shown below, then click the "Download" button.

2 - Installing MongoDB Server

Now, it’s time to install MongoDB Community Server. Make sure to follow along closely and stay in sync with each step.

Locate the downloaded file and double-click it to launch the installer. If a security prompt appears, confirm to proceed. You will then see the following screen; click "Next":

Accept the License Agreement by checking the box, then click "Next":

Click "Complete" to install all features.

Select the options as shown in the image below (these should be selected by default), and then click "Next":

Ensure that the "Install MongoDB Compass" checkbox is unchecked, then click "Next."

Finally, click "Install" to begin the installation process.

During the installation, you may encounter the following dialog; click "OK" to continue the installation process.

After a short while, the installation will be completed; simply click "Finish."

You will now be prompted to restart your system. I recommend restarting to avoid any potential issues; however, if you are installing other software, you can select "No" for now. Just ensure that you start using MongoDB after restarting the system.

Congratulations! You have successfully installed MongoDB Server. Now, it’s time to complete the final step.

Installing MongoDB Compass

MongoDB Compass is a graphical tool for interacting with your MongoDB data visually.

1 - Download MongoDB Compass
Download latest version of MongoDB Compass by following these steps:

Visit the MongoDB Download Center and scroll down to find MongoDB Compass (GUI) under the Tools section. Alternatively, you can go directly to the MongoDB Compass (GUI) download page by clicking this this official link: https://www.mongodb.com/try/download/compass
Scroll down slightly to find the "Download" button. Ensure that you have selected the same options (your version may be the latest one) as shown below, then click the "Download" button.

2 - Installing MongoDB Compass

Now, it's time to install MongoDB Compass.

Locate the downloaded file and double-click it to launch the installer. If a security prompt appears, confirm to proceed, and the installation will begin.

Once the installation is complete, MongoDB Compass will launch automatically. Click "Start" to begin using it. That's it!

Remember, this is the minimal setup required for every developer or database administrator. You can always download additional tools, such as MongoDB Shell, based on your needs from the official website at https://www.mongodb.com/.

Please comment below if you encounter any issues during the installation, and I will do my best to respond to your queries promptly. This will also help new developers in the future.

Don't forget to share this guide. Thank you!

Replacing Digits in a Number Without Converting to String

Arham Rumi — Mon, 22 Apr 2024 05:56:52 +0000

In technical interviews, candidates are often challenged with problems that require creative solutions and efficient problem-solving techniques. One such problem is replacing occurrences of a digit in a number without converting the number to a string or using string operations. In this article, we'll explore a simple solution to this problem using JavaScript.

Problem Statement:
Given a number and two digits (one to be replaced and one to replace with), the task is to replace all occurrences of the digit to be replaced in the number with the replacement digit without converting the number to string or using string operation.

Solution:
We'll approach this problem by iterating through each digit of the number and replacing the specified digit without converting the number to a string. Here's how we'll do it:

Determine the length of the number to set the limit of the divisor.
Initialize a new number variable to store the result.
Iterate through each digit of the number using a while loop.
Extract the first digit of the remaining number by dividing it with the current divisor.
If the extracted digit matches the digit to be replaced, replace it with the replacement digit.
Multiply the modified digit with the current divisor to get its place value.
Add the modified digit to the new number.
Update the original number by taking the remainder after division by the divisor.
Reduce the divisor by a factor of 10 to move to the next digit.

let num = 34645644; // Original Number
let digit_to_be_replaced = 4; // Digit to be replaced
let digit_replace_with = 7; // Digit to replace with
let len = Math.ceil(Math.log10(num + 1)); // Length of the number
let lim = 10 ** (len - 1); // Divisor
let new_num = 0; // New number

// Loop through each digit of the number
while (num) {
    let quotient = Math.floor(num / lim); // Extract the first digit
    // Check if the digit matches the digit to be replaced
    if (quotient == digit_to_be_replaced) {
        quotient = digit_replace_with; // Replace the digit
    }
    quotient *= lim; // Multiply with place value
    new_num += quotient; // Add to new number
    num %= lim; // Update number
    lim /= 10; // Reduce divisor
}

console.log("New Number:", new_num);

Conclusion:
In this article, we've demonstrated a JavaScript solution to the problem of replacing occurrences of a digit in a number without converting the number to a string. By understanding the problem statement and applying an efficient algorithm, we've successfully solved the problem using only numerical operations. This approach demonstrates critical thinking and problem-solving skills, which are essential in technical interviews.

By practicing similar problems and understanding different problem-solving techniques, candidates can enhance their problem-solving abilities and improve their performance in technical interviews.

Resolving "File cannot be loaded because running scripts is disabled on this system" Error in Nodemon

Arham Rumi — Tue, 21 Nov 2023 16:24:45 +0000

nodemon : File C:\Users\MyUser\AppData\Roaming\npm\nodemon.ps1 cannot be loaded because running scripts is disabled on this system. For more 
information, see about_Execution_Policies at https:/go.microsoft.com/fwlink/?LinkID=135170.
At line:1 char:1
+ nodemon app
+ ~~~~~~~
    + CategoryInfo          : SecurityError: (:) [], PSSecurityException
    + FullyQualifiedErrorId : UnauthorizedAccess

Developers using Nodemon to enhance their Node.js development experience may encounter a common hurdle when attempting to execute the tool within a PowerShell environment. The stumbling block manifests as the error message, "File cannot be loaded because running scripts is disabled on this system," creating a roadblock in an otherwise smooth development process.

This error is a consequence of PowerShell's robust security features, specifically designed to safeguard systems from potentially harmful script execution. While these protections are vital for maintaining a secure computing environment, they can occasionally impede the seamless execution of legitimate development tools like Nodemon. There are different levels of execution policy as below:

Restricted: No scripts can be run. Default for the highest level of security.
AllSigned: Only scripts that are digitally signed by a trusted publisher can be run.
RemoteSigned: Allows local scripts but requires downloaded scripts to be signed by a trusted publisher.
Unrestricted: Allows the execution of all scripts with warnings in some cases, regardless of source.
Bypass: Allows us to run scripts from anywhere without warning regardless of the source.

So, in order to resolve this issue, you have to change the execution policy. For that follow the given steps.

Open PowerShell as Administrator - In Start Menu, search for PowerShell. Right-click on the PowerShell icon and choose "Run as Administrator." This ensures that you have the necessary permissions to change the execution policy.
Get Execution Policy - Run the following command to get the current execution policy.

Get-ExecutionPolicy

Change the Execution Policy - Run the following command to set the execution policy to RemoteSigned. This allows locally created scripts to run but requires scripts from the internet to be signed by a trusted publisher

Set-ExecutionPolicy RemoteSigned

If you are prompted like below then simply type A to accept all the changes or you can choose to accept them individually by typing Y.

That's all. Now Run your script with nodemon again and enjoy.

Note: You may need to restart your system in some cases.

Audio Resampling in Node.js - JavaScript

Arham Rumi — Fri, 07 Apr 2023 05:43:16 +0000

In various applications—whether web, mobile, or desktop—there are often times when you need to save audio files. Depending on your requirements, you might prioritize minimizing storage space over sound quality. Audio files can vary significantly in size based on their format; for instance, WAV files are uncompressed and tend to be much larger than MP3 files.

In many cases, the specific file format may not be critical; what matters most is the audio content itself. Converting WAV files to MP3 format is an effective solution for reducing storage usage.

Another approach to consider is resampling, where you adjust the bit depth and frequency of the audio file. While resampling serves various purposes, we will focus on using it primarily to conserve storage space.

Without further ado, let’s explore how this process works. Before executing the code below, ensure that you have installed the FFmpeg tool on your system.

Here is the quick guide to install ffmpeg on Windows.

https://medium.com/@arhamrumi/step-by-step-guide-how-to-install-ffmpeg-on-windows-and-unleash-your-multimedia-potential-2ecda8ed4cf

Assuming that you have successfully installed ffmpeg tool on your system, let's dig into the code.

Import required modules

const path = require("path");
const ffmpeg = require("fluent-ffmpeg");

You have to install fluent-ffmpeg module using this command.

npm i fluent-ffmpeg

Create a function to resample audio file

In this process, fluent-ffmpeg will handle the core tasks, including resampling the audio. Within the audioFrequency() method, you can specify your desired sample rate, and the save() method will save the converted file to the designated path. This conversion operation returns a wealth of information about the process, which is why we store it in the result variable. This allows us to perform additional operations based on that information if needed.

const compressAudio = async (inputFile, outputFile) => {
  const result = ffmpeg(inputFile).audioFrequency(16000).save(outputFile);
  if (result) {
    console.log("Audio compressed successfully");
  }
};

Calling the function

Now we have to call it by giving two arguments. i.e. the first one will be the path to input file and the second one will be the path to our output file.

let inputFile = "path/to/source_file.wav";
let dir_name = path.dirname(inputFile);
let file_name = path.parse(inputFile).name;

let outputFile = dir_name + "\\" + file_name + ".mp3";

await compressAudio(inputFile, outputFile);

That's all. You will see that in your given directory a new file is created.

In conclusion, managing audio files efficiently is essential for optimizing storage and ensuring the best user experience in your applications. By leveraging tools like Fluent-FFmpeg, you can easily convert audio formats and resample files to meet your specific needs. Whether you’re developing web, mobile, or desktop applications, understanding how to handle audio files effectively can enhance your project’s overall functionality.

If you have any questions or encounter any challenges while implementing these techniques, feel free to leave a comment below. Don't forget to share this article with fellow developers who may benefit from it. Happy coding!

Stand Out on GitHub: How to Create an Eye-Catching Profile README

Arham Rumi — Tue, 04 Apr 2023 04:34:55 +0000

Your GitHub profile is your virtual identity in the coding community. But how can you make it stand out? By adding a profile README! In this step-by-step guide, we'll show you how to create an engaging profile README that will showcase your skills, projects, social media and much more to the world.

Create a new repository:

Go to your GitHub profile page
Click on the "Repositories" tab
Click the green "New" button
Name your repository "username" (replace "username" with your actual GitHub username. This is the most important thing)
Select "Public" and check "Add a README file"
Choose a license if you want
Click "Create repository"

2. Edit your README file:

Open your newly created repository
Click on the README file
Click on the pencil icon to edit the file
Add your content using Markdown syntax
Preview your changes by clicking the "Preview changes" tab
When you're done, click the "Commit changes" button at the bottom of the page

Customize your Profile ReadMe You can generate awesome profile ReadMe from many online tools. Some of them are:

Generate the ReadMe file from your selected resource. Copy the code, repeat the step 2 again and commit changes. Congratulations! You have successfully added a profile README to your GitHub profile.
Here is the link to my GitHub profile https://github.com/arham-rumi.

Forem: Arham Rumi

Building a Production Server from Scratch: The Ultimate Guide

Initial Server Access

Check System Codename

Identifying System’s Init System

Update System Packages

Install Essentials

Install Core Runtime — Node.js (LTS Version)

Verify Installation

Install MongoDB

Import the Public Key

Create the List File

Reload the Package Database

Install MongoDB Community Server

Start MongoDB

Check MongoDB Status

Application Deployment

Pull Your Code

Setup Environment

Production Process Management

Validation & Testing

Health Check Verification

External Access Testing

Outro: From Command Line to Confidence

Next Steps

Adding Version Information to a PyInstaller Onefile Executable

Why Add Version Info to Your EXE?

Build a One-File EXE with PyInstaller (Including Binaries & Resources)

Prerequisites

But What Does the Version File Look Like?

Extracting Version Info from cmd.exe

Adding Version Info to Our App

Linking the Version File

Building the Executable

Conclusions

Let’s Hear From You!

Build a One-File EXE with PyInstaller (Including Binaries & Resources)

Running Puppeteer on a Server: A Complete Tutorial

Preparing Server for Puppeteer

Using Puppeteer

Conclusion

Installing Node.js on Windows: A Complete Tutorial

Installing Node.js

MongoDB Installation on Windows: Your 2024 Guide

Installing MongoDB Server

Installing MongoDB Compass

Replacing Digits in a Number Without Converting to String

Resolving "File cannot be loaded because running scripts is disabled on this system" Error in Nodemon

Audio Resampling in Node.js - JavaScript

Stand Out on GitHub: How to Create an Eye-Catching Profile README

Extracting Version Info from `cmd.exe`