DEV Community: Ishan Jarwal

Abandoned project came alive | I built and shipped my first SaaS

Ishan Jarwal — Sat, 30 May 2026 18:35:01 +0000

This is a submission for the GitHub Finish-Up-A-Thon Challenge

I Finally Finished the Side Project That Refused to Die

What I Built

Tonight, I finally deployed a project that has been sitting in my "I'll finish it someday" folder for far too long.

It's called Resumazing, an AI-powered Resume Builder SaaS that helps users create professional resumes with AI assistance, ATS analysis, resume scoring, job fit analysis and multiple resume management features.

What started as a weekend experiment slowly turned into a real product. Every time I thought it was almost done, I found another feature to build, another bug to fix, or another UI improvement to make.

At several points, I considered abandoning it and moving on to the next shiny idea. But this I got the push I needed to finally cross the finish line.

Demo

Live Demo: https://resumazing.vercel.app

The Comeback Story

This project wasn't abandoned because it was broken.
It was abandoned because it was almost finished.
And honestly, that's the hardest stage.

The core functionality already worked months ago, but there were dozens of unfinished details:

Authentication improvements
Resume templating issues
Better validation and error handling
UI polish
Performance fixes
Deployment setup
Countless small bugs

The project sat untouched while I learned new technologies, started new ideas, and kept telling myself I'd come back to it later.

This week, I finally did.

I stopped adding features, focused on completing what already existed, and pushed through the final stretch.

A few hours later, the deployment was live.
Not perfect. Not finished forever.
But finished enough to be used by real people.

And that's a much better place for a project than sitting in a local folder.

Tech I used

I built it on nextjs with industry best practices like precommit scripts with husky, ensuring typesafety all over, writing maintainable code.
I used the follwing :

inngest - for background jobs
dodopayments - for payments and subscription lifecycle handling
@react-pdf/renderer - for making templates
zustand - for state management
zod - for validations
cloudinary - for object storage
react-hook-forms - for form state handling
and many more packages

Find the project here : https://github.com/ishanjarwal/resume-builder-saas

My Experience with GitHub Copilot

GitHub Copilot was surprisingly helpful during the finishing phase.

The hardest part wasn't building new features, it was dealing with all the small tasks that come with polishing a project:

Refactoring code
Generating repetitive boilerplate
Fixing type issues
Writing validation logic
Explaining unfamiliar APIs

For me, Copilot worked best as a development partner rather than an autopilot.

Final Thoughts

Starting projects is exciting.
Finishing them is difficult.

This project taught me that most side projects don't fail because the idea is bad—they fail because the final 10% takes longer than the first 90%.

Tonight, I finally shipped mine.
And honestly, that feels pretty good...

Installing PostgreSQL on Arch Linux | Practical Setup Guide

Ishan Jarwal — Sat, 30 May 2026 17:57:25 +0000

Installing postgres on windows/mac is pretty simple, you just follow the steps on the installation wizard and you get it working. You will also find lots of video tutorials and blogs regarding installation in windows/mac.

But when it comes to linux (specifically arch), things get interesting. Since linux gives you more control, setting up anything on it can seem tricky at first glance but as you go through, you understand each and every step and its purpose.

Before getting into it, understand this : Postgres is not like MongoDB which you initialize once through the CLI by providing the --dbpath flag, it is a system service. Meaning it will run on the system 24x7 (if we configure it that way) and different system users will be able to use it according to the access they have been granted.

First things first : Installation

Always update the packages first :

sudo pacman -Syu

Install PostgreSQL:

sudo pacman -S postgresql

Lets initialize a Database Cluster

PostgreSQL requires a data directory initialization. This is the directory which holds the actual data (one-time step unlike MongoDB) :

sudo -u postgres initdb -D /var/lib/postgres/data

Flags explained

-u postgres → run command as postgres system user initdb → creates system tables & internal structure -D → data directory location

Start & Enable Service

Start server:

sudo systemctl start postgresql

Enable on every boot :

sudo systemctl enable postgresql

Check status:

systemctl status postgresql

Enter psql Shell

What is psql ? It is a command line interface to interact with out postgres service, databases, relations etc.

Lets enter the psql shell with the user “postgres”.

On installing postgres, a new user named “postgres” is generated with default privileges.

sudo -u postgres psql

Why no password?

Default auth configuration is the “peer” auth. Peer auth uses our OS user to login
OS user identity is trusted

Create Role for a Project

It is always a good practice to create a separate role for every major project. This way you follow modular principles.

Inside psql:

CREATE ROLE myapp WITH
  LOGIN
  PASSWORD 'devpass123'
  CREATEDB;

Meaning:

LOGIN → allows authentication
PASSWORD → required for apps/ORMs
CREATEDB → grant access to create databases

Create a Database

CREATE DATABASE myapp_db OWNER myapp;

Ownership = full control over that DB.

Some frequently used and useful psql Commands

List Databases

\l

List roles (users)

\du

List tables/relations

\d

Show current connection details

\conninfo

Show the active role

SELECT current_user;

Connection URL Format

To connect to the database, you will need a url (Yes this is the one you add in your environment variables)

General structure : postgresql://USER:PASSWORD@HOST:PORT/DATABASE

Example : postgresql://myapp:devpass123@localhost:5432/myapp_db

This url can be used by:

Prisma
ORMs
Drivers
CLI tools

Enable Password Authentication (Critical for Prisma)

Edit config:

sudo nano /var/lib/postgres/data/pg_hba.conf

Change these lines according to your needs :

local   all   all                 md5
host    all   all   127.0.0.1/32  md5
host    all   all   ::1/128       md5

Replace md5 with one of the following :

trust → no password
peer → OS identity
md5 / scram-sha-256 → password-based login

Restart PostgreSQL

To apply the config changes :

sudo systemctl restart postgresql

Testing our Connection

psql "postgresql://myapp:devpass123@localhost:5432/myapp_db"

psql -U myapp -d myapp_db -h localhost -W

Flags explained

-U → database role -d → database name -h → host (forces TCP) -W → force password prompt

Some Common Errors & Causes you might face

password authentication failed → wrong password
database does not exist → DB missing
role does not exist → user missing
could not connect to server → service stopped / wrong port

Again, remember

PostgreSQL:

Always-running service
Config-driven behavior
URL = connection info only

No manual server start like MongoDB.

Happy building 🚀

Git Rebase vs Reset vs Revert | When to use What ?

Ishan Jarwal — Fri, 29 May 2026 12:54:04 +0000

The Scenario: "Oops, I Made a Messy Commit History"

Imagine you're working on a feature branch called feature/login-page. You’ve made a few commits, but now :

One of the commits has a bug.
Another commit has a wrong commit message.
Your commit history looks like a jumbled mess compared to main.

Time to clean it up! But… should you rebase, reset, or revert?

First, Let’s Understand the Core Idea of Each:

Command	What it Does	Safe for Shared Branches?
`rebase`	Rewrites commit history to make it linear and clean	No, unless used carefully
`reset`	Moves the HEAD and branch pointer to a different commit	No, dangerous on shared branches
`revert`	Creates a new commit that undoes a previous commit	Yes, safe to fix public history

1. Git Rebase : "Let’s Rewrite History Neatly"

What is it?

git rebase allows you to move or "replay" your commits onto another branch or rearrange them to make a clean, linear history.

When to Use?

You want to clean up messy commit history before merging.
You want to squash commits.
You want to change commit messages.

Example:

You have these commits in feature/login-page:

A — B — C — D  (feature/login-page)         
        ↑       
      Buggy commit (C)

You want to fix commit C and clean up the message in D.

Solution: Interactive Rebase

git rebase -i HEAD~3

You’ll see something like this:

pick abc123 B pick def456 C pick ghi789 D

You can now:

Change "pick" to "edit" for C to fix the bug.
Change "pick" to "reword" for D to fix the commit message.
Squash commits if needed.

Important:

This rewrites commit hashes.
If your branch is pushed and shared, rebasing can mess up others' history. Use with care!

2. Git Reset : "Let’s Go Back in Time (Dangerously Powerful)"

What is it?

git reset moves your branch pointer (HEAD) to a previous commit. It can unstage files, remove commits, or even delete code changes.

Types of Reset:

Command	What happens?
`git reset --soft`	Keeps your changes staged.
`git reset --mixed`	Unstages changes but keeps them in the working directory.
`git reset --hard`	Deletes your changes completely. Dangerous!

When to Use?

You made local commits you don’t want anymore.
You want to uncommit but keep the changes.

Example:

You made two useless commits on top of main and want to remove them.

A — B — C — D  (main)              
            ↑            
            Your branch (HEAD)

To undo D and C:

git reset --soft HEAD~2

Your changes are still there but unstaged (due to --soft flag).
If you want to kill the changes, do

git reset --hard HEAD~2

After that your git timeline will look like this :

A — B  (main)
    ↑            
    Your branch (HEAD)

Important:

Never reset a branch that is already pushed and shared with others.
Resetting can permanently lose work (especially --hard).

3. Git Revert : "The Safe Undo Button"

What is it?

git revert creates a new commit that undoes the changes of a previous commit. It preserves history.

When to Use?

You want to undo a bad commit in a shared branch.
You want to keep history intact but fix a mistake.

Example:

Commit C introduced a bug. But you’ve already pushed it to origin/main.

A — B — C — D  (main)           
             ↑            
            Bug lives here

You can revert C safely:

git revert <commit-hash-of-C>

Git will create a new commit :

A — B — C — D — E  (main)                    
                ↑                 
              "Revert C"

Important:

Safe for shared/public branches.
Doesn’t remove the commit but inverts its changes.

Quick Summary: When to Use What?

Command	Use When…
`git rebase`	You want to rewrite and clean history (local-only).
`git reset`	You want to remove commits or unstage changes locally.
`git revert`	You need to undo commits safely in shared branches.

Visual Cheat Sheet

"I messed up a commit and want to fix it before pushing" → Rebase / Reset (local only)
"I pushed a bad commit, now I need to undo it on remote" → Revert
"I made several ugly small commits, want to squash them" → Rebase -i

Final Tips

Never rebase or reset public history unless you know what you’re doing.
Use git log --oneline --graph to visualize the history before making changes.
Always backup your branch with git branch backup/my-branch before risky operations.

Learn Package Management on Arch Linux: pacman & yay

Ishan Jarwal — Fri, 29 May 2026 07:59:48 +0000

Part 1: Understanding `pacman`

pacman is the default package manager for Arch Linux. It directly interacts with the official repositories and handles installation, updates, and removal of software.

Basic Syntax

sudo pacman [options] [package_name]

Common pacman Commands

Task	Command	Description
Update package database and system	`sudo pacman -Syu`	Sync package list (`-Sy`) and upgrade all packages (`-u`).
Install a package	`sudo pacman -S <package>`	Installs package from official repo.
Remove a package	`sudo pacman -R <package>`	Removes a package (keeps dependencies).
Remove a package and its unused dependencies	`sudo pacman -Rns <package>`	Clean uninstall — removes package, configs, and dependencies.
Search for a package	`pacman -Ss <keyword>`	Search available packages.
List installed packages	`pacman -Q`	Shows all installed packages.
Show package info	`pacman -Qi <package>`	Displays metadata (version, size, dependencies).
Clean cache	`sudo pacman -Sc`	Removes old packages from cache.

Official Reference:

Pacman Manual - ArchWiki

🧹 Pro Tip

To free up space, remove unused dependencies and old cached packages:

sudo pacman -Rns $(pacman -Qdtq)
sudo pacman -Scc

Part 2: Using `yay` for AUR Packages

The Arch User Repository (AUR) contains community-maintained build scripts (PKGBUILDs) for software not in the official repositories.

yay (Yet Another Yaourt) is a lightweight, fast, and user-friendly AUR helper that automates the build and installation process.

Basic Syntax

yay [options] [package_name]

Common yay Commands

Task	Command	Description
Update everything (official + AUR)	`yay -Syu`	Sync and upgrade both official and AUR packages.
Install an AUR package	`yay -S <package>`	Automatically fetches, builds, and installs from AUR.
Search for AUR packages	`yay -Ss <keyword>`	Search both official and AUR repositories.
Remove a package	`yay -Rns <package>`	Same as pacman — removes package + unused dependencies.
Clean build cache	`yay -Sc`	Clean yay’s build directory.
List all AUR packages	`yay -Qm`	Shows all manually installed (AUR) packages.
Check for outdated AUR packages	`yay -Qua`	Lists AUR updates available.

💡 Tip: Unlike pacman, yay doesn’t need sudo for most operations until the build process actually installs system files — it will prompt automatically.

Official Reference:

Yay GitHub Repository

Flag Summary

Flag	Tool	Meaning
`-S`	pacman/yay	Install package(s)
`-R`	pacman/yay	Remove package(s)
`-Ss`	pacman/yay	Search package in repos
`-Qi`	pacman	Show package info
`-Qm`	yay	List manually installed (AUR) packages
`-Syu`	pacman/yay	Sync database and upgrade all packages
`-Rns`	pacman/yay	Remove package + dependencies + configs
`-Sc`	pacman/yay	Clean package cache
`-Qdtq`	pacman	List orphaned packages

A Comprehensive and Comfy Guide to Git.

Ishan Jarwal — Fri, 29 May 2026 07:47:15 +0000

Git is not just a tool; it’s a life-saver for developers. It helps you track changes, collaborate with others, and never lose your work. This guide is designed to be a comfy walkthrough of Git , not too heavy on jargon, but packed with useful knowledge.

A Tiny History of Git and Why You Should Care

Git was created by Linus Torvalds in 2005, the same genius who built Linux. It was born out of necessity when the Linux community needed a version control system that was fast, distributed, and free.

Today, Git powers everything from hobby projects to massive codebases like those at Google, Microsoft, and Facebook. Whether you're working on a personal website or contributing to open-source, Git is the industry standard.

Where is Git

Software Development (obviously!)
Documentation Projects
Collaborative Design Workflows
Versioning for Configuration Files

If it involves files that change over time, Git can manage it.

Key Git Terminologies

Repository (Repo)
A directory where your project's Git history is stored. It's like a folder, but smarter.
Staging Area
Think of this as a "waiting room" where changes sit before you officially save them in the project history.
Commit
A snapshot of your project at a specific point in time. This is how you save your work in Git.
Push
You "push" commits to a remote repository (like GitHub) so others can see your work.
Remote
A version of your project that's hosted on the internet or another network.

Setting Up Git for the First Time

Install Git
Download from git-scm.com
Configure Your Identity
Before you do anything, tell Git who you are. We do this by telling git what is our username and email

git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

Initialize a Git Repository Navigate to your project folder and run:

cd /path/to/your/project's/root
git init

This creates a .git folder in your project. If you don't know, folders starting with a "." are hidden folders so you might not see it in the folder tree. This is where the information about your codebase is saved.

Tracking Changes (Staging & Committing)

Check Project Status

git status

This shows which files have been changed, which are staged, and which are not. You will see something like this in your terminal.

Add Files to Staging Area

git add filename.txt

Or add everything:

git add .

This is one step before committing your changes. Note that the files added to the staging area are the only ones going to be committed. All other files will be "unstaged files"

Committing the Changes

git commit -m "Add feature X"

Git expects you to associate every commit with a message. After running this command, a snapshot of your staged changes will be saved as a "commit".

Viewing Commit History

git log

This shows all commits in your repo. Use q to exit log view.

The HEAD in Git points to the current snapshot (commit) you are working on. Think of it as "where you are" in your project history.

Understanding Branches

A branch in Git is like creating an alternate universe for your code where you can try out new features without disturbing the main project. I would call this the most amazing feature offered by Git. Think of it as you are working on a feature and committing the changes step by step.

Eg : Initialize Project -> create homepage -> add images -> change fonts . . .

But parallel to this workflow, you also want to create a new feature say "Authentication" in the same project and without disturbing the main flow.

When you first initialize your project, the default branch you work on is either "master" or "main"

Create a New Branch

git branch new-feature

Switch to That Branch

git checkout new-feature

Or Do Both in One Command

git checkout -b new-feature

List All Branches

git branch

Delete a Branch

git branch -d old-feature

You can learn more about "Merging Branches" from here. It is an advanced git concept, hence it will not be discussed here.

Push Your Code to GitHub

Till now, we have created our repo, some commits (our checkpoints) and also branches. But all of this resides in our local machine. If anything goes wrong your pc, all of your data will be lost. For this purpose we have "Github", a place where you can upload your code so that it stays safe.

Following theses steps you can do it easily.

Create a Github account and the repo.

First step is to create your github accout. Simply add your details, verify your account and your are good to go.
Now you can click the "Create New Repository" button, give it a name, make it public/private according to you and hit create.
Now your remote repository is created and we need to connect it to our local git project, to do that, follow these steps

Add Remote URL

git remote add origin https://github.com/yourusername/your-repo.git

here, origin is nothing but an alias for your remote repository, you can see all the aliases by this command

git remote -v

Push to Remote

git push -u origin main

This will "push" or upload our codebase to our remote repository. The "-u" flag tells Git to set the remote branch (origin/main) as the upstream (or default) branch for your local branch (main).

Congrats, your code is now safe on github.

Bonus Tips: Git in VSCode

If you prefer clicking buttons over typing commands, Visual Studio Code has an excellent Git GUI.

Must-have VSCode Git Extensions:

GitLens: Supercharge your Git experience.

Git Graph: Visualize your branches and commits.

GitHub Pull Requests and Issues: Manage PRs from within VSCode.

What's Next?

This guide covers the comfy essentials to get you started. In the next post, we'll explore advanced Git concepts like merge conflicts, rebasing, reverting commits, and more.

For now, get your hands dirty and start committing!

That's it! You're now Git-ready.

DEV Community: Ishan Jarwal

Abandoned project came alive | I built and shipped my first SaaS

I Finally Finished the Side Project That Refused to Die

What I Built

Demo

The Comeback Story

Tech I used

My Experience with GitHub Copilot

Final Thoughts

Installing PostgreSQL on Arch Linux | Practical Setup Guide

First things first : Installation

Lets initialize a Database Cluster

Start & Enable Service

Enter psql Shell

Create Role for a Project

Create a Database

Some frequently used and useful psql Commands

Connection URL Format

Enable Password Authentication (Critical for Prisma)

Restart PostgreSQL

Testing our Connection

Some Common Errors & Causes you might face

Git Rebase vs Reset vs Revert | When to use What ?

The Scenario: "Oops, I Made a Messy Commit History"

First, Let’s Understand the Core Idea of Each:

1. Git Rebase : "Let’s Rewrite History Neatly"

What is it?

When to Use?

Example:

Solution: Interactive Rebase

Important:

2. Git Reset : "Let’s Go Back in Time (Dangerously Powerful)"

What is it?

Types of Reset:

When to Use?

Example:

Important:

3. Git Revert : "The Safe Undo Button"

What is it?

When to Use?

Example:

Important:

Quick Summary: When to Use What?

Visual Cheat Sheet

Final Tips

Further Reading

Learn Package Management on Arch Linux: pacman & yay

Part 1: Understanding pacman

Basic Syntax

Common pacman Commands

🧹 Pro Tip

Part 2: Using yay for AUR Packages

Basic Syntax

Common yay Commands

Flag Summary

Further Reading:

A Comprehensive and Comfy Guide to Git.

A Tiny History of Git and Why You Should Care

Where is Git

Key Git Terminologies

Setting Up Git for the First Time

Tracking Changes (Staging & Committing)

Add Files to Staging Area

Committing the Changes

Viewing Commit History

Understanding Branches

Create a New Branch

Switch to That Branch

Or Do Both in One Command

List All Branches

Delete a Branch

Push Your Code to GitHub

Create a Github account and the repo.

Add Remote URL

Push to Remote

Bonus Tips: Git in VSCode

What's Next?

Part 1: Understanding `pacman`

Part 2: Using `yay` for AUR Packages