DEV Community: NIKHIL KUMAR

Building a Privacy-First, revenue platform for creators.

NIKHIL KUMAR — Mon, 06 Apr 2026 08:19:28 +0000

Nowdays,the creator economy is booming, but there is a massive blind spot: calculating true net income. If you are a creator on YouTube, Twitch, or Substack, estimating your earnings usually involves clunky spreadsheets or ad-riddled calculator sites that harvest your financial data. Most calculators only show gross estimates, ignoring platform cuts, taxes, and audience geography.

I wanted to fix this. But more importantly, as a developer, I wanted to build it in the most lightweight, privacy-respecting way possible.

That is how Crecaly was born: a revenue calculator for the creator economy that figures out your true take-home pay across 15+ platforms. And I built it entirely as a serverless Progressive Web App (PWA) using pure Vanilla JavaScri``pt, HTML, and CSS.

Here is why I ditched the modern framework hype and went back to basics.

🛑 The Problem with Modern Financial Tools
When building a tool that handles sensitive data—like someone’s income, tax bracket, and financial goals—privacy should be the default, not an opt-in feature.

Most calculator apps send user inputs back to a server to process the logic, often storing that data for analytics or retargeting. I wanted Crecaly to be the "ultimate boss of privacy."

The constraints I set for myself:

Zero backend data collection.

Lightning-fast load times.

No heavy frameworks.

🛠 The Tech Stack: Vanilla JS + PWA
It is tempting to spin up a React or Vue project for everything, but for a standalone utility tool, shipping a massive JavaScript bundle felt like overkill.

By sticking to HTML, CSS, and Vanilla JS, I kept the footprint incredibly small.

Client-Side Processing (Zero Backend) All the complex math—factoring in the unique fee structures of 15+ different platforms, calculating estimated taxes, and adjusting for audience geography—happens locally in the user's browser.

Because there is no database to ping, the UI updates instantly. More importantly, the user's financial projections never leave their device.

The PWA Advantage I structured Crecaly as a Progressive Web App. By utilizing a simple manifest.json and a Service Worker, users can install the tool directly to their home screens (mobile or desktop).

It feels like a native app.

It bypasses the gatekeeping and 30% fees of traditional app stores.

🧠 Building "Chase Mode" (Reverse-Math Logic)
One of the most fun features to build was what I call "Chase Mode".

Usually, calculators work forward: Input Views -> Output Money.
Chase Mode works backward: Input Target Money -> Output Required Views/Subs/Sales.

From a logic standpoint, it required building a dynamic reverse-math engine. If a creator wants to net exactly $5,000 this month, the JS logic has to dynamically add back the tax estimates and specific platform fees to tell them exactly how many Twitch subs or YouTube views they need to hit that goal. Doing this instantaneously via DOM manipulation without a virtual DOM was a great exercise in efficient event listener management.

🚀 Takeaways from Going "Vanilla"
Building Crecaly reminded me that we don't always need an overly engineered stack to ship a great product.

Speed is a feature: Without a framework, the Lighthouse scores are flawless.

Privacy builds trust: "Zero backend" is a massive selling point when marketing to users tired of data harvesting.

Vanilla JS is powerful: Modern JavaScript (ES6+) is so robust that I rarely found myself missing a framework for a utility application like this.

How I Built a Zero-Backend Image Processing PWA using purely Vanilla JS (and HTML5 Canvas)

NIKHIL KUMAR — Mon, 23 Mar 2026 13:44:22 +0000

As web developers, we've normalized a terrible habit: uploading user images to third-party cloud servers just to perform basic operations like compression, resizing, or formatting.

Not only does this introduce latency and increase server costs, but it's also a massive privacy risk for users handling sensitive assets. I wanted to see if I could eliminate the server entirely.

My goal was to build a fully functional, offline-capable image utility suite with zero backend dependencies. The result is Pahadify, a 100% client-side Progressive Web App (PWA) built with pure Vanilla JS, HTML, and CSS.

Here is a breakdown of the architecture, the challenges of client-side processing, and how I implemented browser-based powers.

The "Zero-Backend" Rule

Modern browsers are incredibly powerful. By leveraging the File API and the HTML5 <canvas> element, we can manipulate pixels directly on the user's local machine.

To keep the bundle size tiny and performance blazing fast, I opted for Vanilla JavaScript over heavy frameworks like React or Angular.

The core flow looks like this:

User selects an image.
FileReader reads the file locally into memory as a Data URL.
An Image object is created and drawn onto a hidden <canvas>.
The canvas exports the manipulated pixels back into a compressed format (e.g., WebP or JPEG) using canvas.toDataURL().

Absolutely zero network requests are made during this process. You can literally turn off your Wi-Fi and it processes instantly.

The Hard Part: Client-Side Live Photo Trainer tool.

While basic compression and resizing were straightforward, I wanted to push the browser's memory limits by adding a live photo trainer tool to analyze user face and environment in real time.

Doing this server-side is easy. Doing it client-side without crashing the browser tab required careful memory management.

A custom system to analyze face in real time.

To achieve this i have to create an ai with math to analyze skin tone and surrounding in browser only.

Making it a True PWA
To make it a true alternative to cloud tools, it must be installable like a native app.

Because the app relies entirely on client-side logic and doesn't need to ping an external API for compression algorithms, the experience is identical to the online but feels like offline experience.

Try it out (and break it)
Building a zero-backend tool completely shifted how I view web performance. We don't always need an AWS Lambda function or a Node.js backend to process files.

I’ve bundled all 18+ tools (including the live photo trainer, custom canvas editors, and an integrated rating system) into the latest release of the project.

Try out Pahadify and give your honest reviews about it: https://thepahadify.com/

Stop Uploading Your Photos To Server: I built a 100% Client Side Image Editor With 18 Tools that runs in your browser

NIKHIL KUMAR — Thu, 05 Feb 2026 09:49:06 +0000

The "Bloat" Problem
We live in an era where opening a simple image editor requires downloading 500MB of software or waiting for a heavy web app to load 20MB of JavaScript frameworks. Even worse, most free online tools force you to upload your private photos to their servers just to crop or resize them.

I decided to fix this.

I am a solo developer based in INDIA, Himachal Pradesh, and I spent the last few months building Pahadify.

What is Pahadify?
It is a client-side image editing utility. It does not look like Photoshop but it is powerful as any other paid software, and it doesn't try to be. It focuses on one thing: Speed and Privacy with raw power.

⚡ Ultra Lightweight: The entire build is approximately 1.5MB.

🔒 100% Privacy: It runs entirely in your browser. Your images never leave your device.

📱 PWA Ready: It installs as a native app on your phone or desktop.

The Tech Stack: "Vanilla" Flavor
As a developer, I had a choice: use heavy libraries that handle everything for me, or write efficient, clean code. I chose the latter.

HTML5 Canvas: For all the image manipulation logic.

Vanilla JavaScript: No React, No Vue, No jQuery. Just pure JS.

CSS3: For a responsive, lightweight UI.

By avoiding heavy frameworks, I ensured that the app loads instantly, even on 3G networks in the mountains where I live.

Why "Client-Side" Matters
We are seeing a massive shift in how companies treat user data. When you upload a photo to many "free" editors, you are often unknowingly training their AI models.

Pahadify takes a different approach. Because the logic happens on your CPU, I don't need to see your data. I don't want your data. I just want to provide the tool.

The "Mission" from Chamba
There is a stereotype that world-class tech only comes from Silicon Valley or Bangalore. I want to prove that efficient, privacy-focused tools can be built from anywhere—even a small town in the Himalayas.

Try it out (and break it!)
I am looking for feedback from the developer community.

How is the load time for you?

Does the PWA install correctly on your device?

👉 You can try it here: [https://thepahadify.com/]

How I Built a Client-Side Image Resizer (Lightning Fast) using Vanilla JS

NIKHIL KUMAR — Fri, 02 Jan 2026 02:54:54 +0000

I recently noticed a problem: most "free" image resizing tools force students to upload sensitive documents (Aadhaar, Marksheets) to a remote server just to crop them. That didn't sit right with me.

So, I built PAHADIFY – a 100% Client-Side image toolkit that runs entirely in the browser. No server uploads, no data leakage, and it works offline.
Click Now - https://thepahadify.com/