DEV Community: Akshat Raj

How I Built a 100% Client-Side AI Background Remover with Next.js and WebAssembly (Zero Server Costs)

Akshat Raj — Thu, 03 Sep 2026 18:40:16 +0000

Every single time you want to remove an image background, popular SaaS platforms push you behind a paywall, throttle export resolutions, or require cloud uploads.

Uploading personal photographs, government IDs, and signatures to unvetted cloud servers isn't just inefficient—it's a major privacy flaw.

To solve this, I built CUTOUT Studio: a high-performance, 100% in-browser background remover powered by Next.js, WebAssembly (WASM), and Web Workers.

⚡ Zero Server Costs: The client’s browser CPU/GPU executes the model.
🔒 Air-Gapped Privacy: After the initial page load, it functions entirely offline.
📄 Biometric Standard Presets: Built-in Otsu thresholding engine to frame and compress signatures/portraits under 50KB for examination portals (UPSC, SSC, IBPS).

🛠️ The Architecture

Running computer vision models on the client side usually freezes the main UI thread. Here is how CUTOUT Studio circumvents that:

1. Web Worker & OffscreenCanvas Offloading

Heavy image segmentation and pixel manipulation never touch the main UI thread.

Input image buffers are passed via transferable objects to a background Web Worker.
The Worker processes the image on an OffscreenCanvas, computing alpha masks without causing layout shifts or button freezes.

2. Ink Signature Binarization (Otsu Thresholding)

For government job applications, applicants struggle to clean shadow-heavy, ballpoint pen signatures on white paper.

Instead of relying on deep neural networks for simple thresholding, the engine includes a fast, native mathematical pass using Otsu’s thresholding method:

Converts raw RGB pixels to grayscale.
Dynamically iterates over pixel histogram variances to determine the optimal threshold between foreground ink and background paper.
Forces crisp, binary monochrome output with zero gray compression artifacts.

⚡ The Economic Arbitrage: $0 Infrastructure

Traditional SaaS relies on GPU clusters (AWS EC2 instances or serverless containers) that cost real money per inference.

By pushing execution to the browser:

Infrastructure costs are $0 (hosted on static edge storage).
Zero user data collection or telemetry.
Horizontal scaling is infinite—whether 1 user visits or 50,000, our server load remains essentially flat.

🚀 Try It Live & Contribute

The core studio engine is free and completely open-source.

🌐 Live Web App: cutout.onepersonai.in
⭐ GitHub Repository: AkshatRaj00/cutout-studio

We have marked several beginner-friendly tasks (good-first-issue) on GitHub for clipboard shortcuts and canvas previews. PRs, stars, and architectural feedback are welcome!

The 20KB File Limit Dilemma: Why Exam Portals Reject Uploads and How OnePersonAI’s KBFixer Solves It In-Browser

Akshat Raj — Tue, 01 Sep 2026 11:55:42 +0000

Every year across India, millions of aspirants register for competitive government examinations—including UPSC Civil Services, SSC CGL, State PSCs, Banking, and Defense recruitments. Yet, on the final submission days, the single most frustrating bottleneck isn't the syllabus or the server load; it is the rigid, zero-tolerance file upload portal.

Almost every official recruitment portal enforces strict legacy criteria:

Candidate Photograph: Strictly 20 KB to 50 KB, exact 350x450 pixel resolution, clean background.

Candidate Signature: Strictly 10 KB to 20 KB, high-contrast ink, specific aspect ratios.

Supporting Documents / Certificates: PDF files strictly restricted under 200 KB or 300 KB.

If an uploaded file is 50.4 KB, the portal throws an instant validation error: "File size out of specified limits." If a candidate aggressively compresses it down to 18 KB, the image artifacts turn their facial features into a smudged blur—often leading to form rejections during scrutinized document verification.

The Hidden Risk: Why Traditional Online Compressors Fail Candidates
When faced with a ticking clock before an application deadline, most candidates scramble to use generic online file compressors. This approach carries severe technical and privacy downsides:

Severe Compression Artifacts: Standard web compressors apply aggressive lossy algorithms that strip critical high-frequency image data. While the file size drops, key facial contours blur out. If an invigilator cannot verify the photo printed on the admit card at the exam hall, the candidate faces disqualification.

Arbitrary Output Sizes: Most tools do not offer exact kilobyte targets. They compress using generic "Low / Medium / High" sliders, forcing candidates into endless trial-and-error uploads.

Severe Biometric Privacy Exposure: To process an image, traditional cloud-based tools require users to upload their signatures, identity cards, and passport-size photographs to remote third-party servers. Storing biometric identity data on unverified web servers creates huge security risks.

Engineering the Solution: OnePersonAI’s Privacy-First Architecture
To tackle this widespread structural problem, OnePersonAI—an engineering lab focused on building lightweight, zero-bloat web utilities and developer architectures—engineered KBFixer.

Unlike conventional platforms that route sensitive user files through remote backends, OnePersonAI designed KBFixer with a strictly Client-Side-First philosophy.

How KBFixer Works Inside Your Browser:
Zero Server Uploads: Leveraging modern browser technologies including the HTML5 Canvas API and WebAssembly, KBFixer performs all pixel re-sampling, spatial filtering, and quantization directly inside your device's local memory (RAM). Your signatures and photos never leave your computer or smartphone.

Exact Kilobyte Targeting: Candidates do not need to guess compression percentages. If a UPSC portal requires an image under 50 KB, users can set the slider directly to 35 KB. The in-browser engine dynamically computes the optimal compression curve to land precisely at the target size while preserving maximum visual sharpness.

Pre-Built Exam Portal Dimensions: KBFixer integrates calibrated presets for major national exams (UPSC, SSC, IBPS, State Boards), automatically enforcing aspect ratios (such as 3.5 cm x 4.5 cm) so candidate headshots never look horizontally squashed or vertically distorted.

Visual Page & PDF Management: Beyond images, candidates dealing with educational transcripts and category certificates can visually inspect multi-page PDFs, eliminate unnecessary sheets, and compress documents under 200 KB in seconds.

Step-by-Step Guide: Perfect Exam Document Formatting
To ensure your application passes automated portal parsers on the first attempt, follow these standard steps:

Crop to Proportions First: Do not compress a wide landscape selfie. Use a proper crop tool to isolate the head and upper shoulders against a light background, keeping eyes centered.

Enhance Signature Contrast: Crop closely around the signature strokes on clean white paper. Ensure the ink is deep black or navy blue without grey shadows from uneven room lighting.

Aim for the Safe Midpoint: If the permissible range is 20 KB to 50 KB, configure your target size to 35 KB. Aiming for the exact boundaries (like 20.1 KB or 49.8 KB) risks server-side metadata discrepancies triggering a false rejection.

Export Locally: Process the file through KBFixer to maintain 100% data confidentiality, preview the text/facial sharpness, and download the ready-to-upload .jpg file.

The Road Ahead for Digital Utilities
Software should solve everyday friction without demanding unnecessary user data. By coupling high-performance local processing with intuitive user interfaces, OnePersonAI continues to build tools that eliminate digital roadblocks for students, professionals, and developers alike.

Before submitting your next examination form, format your documents correctly, protect your digital footprint, and eliminate portal upload errors permanently.

Why We Built KBFixer: A 100% In-Browser File & Image Optimizer (No Server Uploads)

Akshat Raj — Sat, 01 Aug 2026 20:35:00 +0000

Hey Dev Community! 👋

I'm Akshat Raj, founder at OnePersonAI. Today, I'm launching our latest developer utility: KBFixer.

🛑 The Problem

Most online image compressors and PDF optimizers require uploading your sensitive files to remote cloud servers. For personal documents, government application forms, or internal project assets, this introduces privacy risks and slow upload/download latency.

⚡ The Solution: KBFixer

We engineered KBFixer to execute 100% client-side inside your web browser using WebAssembly and Web Workers.

Zero Server Uploads: Your files stay strictly in local memory.
Instant Speed: No waiting for files to upload or download over slow networks.
Portal Ready: Target exact file sizes (e.g., compress PDFs to 20KB or images to 50KB) for strict portal requirements.
Multi-Format Support: Handle Images, PDFs, DOCX, and PPT files seamlessly.

🌐 Try it out

Live Utility: kbfixer.onepersonai.in
Main Suite: onepersonai.in

📢 Connect & Community

Telegram: Join Updates
YouTube: @OnePersonAI_Official
Twitter / X: @onepersonai_in

I'd love your technical feedback, thoughts on the UI, or performance suggestions! Let's discuss in the comments below. 🚀

🎵 OneMusic

Akshat Raj — Thu, 07 May 2026 16:46:35 +0000

I built a 100% free, ad-free music streaming app for Android — No subscription, no login, open source [APK in comments]

Body:
Hey everyone! 👋

I've been working on OneMusic — a free, open-source music streaming app for Android that I built using Flutter.

Why I built it:
I was tired of ads interrupting my music every 30 seconds on Spotify free tier and JioSaavn. So I built my own solution.

What it does:

🎵 Stream millions of songs — Hindi, Punjabi, English, all genres

❌ Zero ads — literally none

🔓 No login required to listen

🎧 Background playback + lock screen controls

🔍 Live search suggestions as you type

❤️ Like songs & manage queue

⚡ Fast, lightweight, smooth dark UI

Tech Stack: Flutter + JioSaavn API + YouTube + Hive + media_kit

📥 Download APK: https://github.com/AkshatRaj00/OneMusic/releases/latest
⭐ GitHub: https://github.com/AkshatRaj00/OneMusic

Would love your feedback and bug reports! 🙏

Built by a solo developer from India 🇮🇳

I Built a Free Ad-Free Music App with Flutter — Here's How

Akshat Raj — Thu, 07 May 2026 16:39:04 +0000

The Problem
Every music app today either:

Shows you ads every 30 seconds

Charges ₹119–₹179/month for basic features

Requires a login just to play a song

I got tired of it. So I built OneMusic.

What is OneMusic?
OneMusic is a 100% free, ad-free, open-source music streaming Android app built with Flutter. It streams from JioSaavn and YouTube, stores nothing on servers, and requires zero login.

Tech Stack
text
Flutter 3.x → Cross-platform UI
media_kit → ExoPlayer-based playback
JioSaavn API → Music catalog (Hindi/Regional)
YouTube API → Global music fallback
Hive → Local storage (history, likes)
Provider → State management
audio_service → Background + notification controls
Key Features Built

Live Search Suggestions
Instead of waiting for Enter, results appear as you type with 350ms debounce using Timer.cancel() pattern.
Background Playback
Using media_kit + audio_service for proper Android notification controls.
Smart Queue Management
Users can add to queue, skip, and manage playlist on the fly.

GitHub & Download
⭐ GitHub: https://github.com/AkshatRaj00/OneMusic
📥 APK: https://github.com/AkshatRaj00/OneMusic/releases/latest

A product by OnePerson AI — https://onepersonai.in

Drop your feedback in the comments! 🙏

“AI-Powered Global Economic Insights Dashboard”

Akshat Raj — Fri, 03 Apr 2026 20:17:25 +0000

I built a Global Economic Intelligence Dashboard that analyzes GDP trends across countries in real time.

This project allows users to explore historical economic data, compare multiple countries, and derive insights through interactive visualizations.

Live Demo: https://gdp-dashboard-s58r0lq7zwk.streamlit.app

Tech Used:

Python
Streamlit
Data Visualization

This is part of my journey in building real-world data intelligence systems.

Open to feedback and collaborations.

AI #DataScience #MachineLearning #Developer #India

VisaIQ — AI-Powered Visa Processing Intelligence System

Akshat Raj — Fri, 03 Apr 2026 20:00:12 +0000

Built by Akshat Raj | Founder of OnePersonAI

VisaIQ is an advanced machine learning system designed to predict visa processing timelines with high accuracy while delivering AI-powered insights for smarter decision-making.

This project combines predictive modeling with real-time AI analysis to transform how individuals and organizations understand visa workflows.

Live Application

https://visapredictor-upltsgqphxttgzdnzheset.streamlit.app/

Overview

VisaIQ is not just a prediction tool — it is an intelligent system that analyzes historical visa data to generate actionable insights. It leverages machine learning models along with AI reasoning to provide both numerical predictions and contextual recommendations.

Key Features

Predict visa processing time using trained machine learning models
Generate confidence scores and processing ranges
AI-powered insights using Google Gemini
Support for custom dataset uploads (CSV-based training)
Clean and responsive user interface
Real-time results with minimal latency

Problem Statement

Visa applicants often face uncertainty regarding processing timelines, leading to poor planning and decision-making. Existing tools lack predictive intelligence and contextual understanding.

VisaIQ addresses this gap by providing data-driven predictions combined with AI-generated insights.

Technical Architecture

Frontend: Streamlit (Interactive UI)
Machine Learning: Scikit-learn (Random Forest, Gradient Boosting)
AI Layer: Google Gemini 1.5 Flash
Data Processing: Pandas, NumPy
Deployment: Streamlit Cloud

How It Works

Upload historical visa data (CSV format)
Train a machine learning model dynamically
Input country and visa type
Get predicted processing time
Receive AI-generated insights for better decision-making

Sample Dataset Format

country,visa_type,application_date,decision_date
India,Student,2024-01-10,2024-02-14
USA,Work,2024-03-01,2024-04-20
UK,Tourist,2024-06-15,2024-06-30

Local Setup

git clone https://github.com/AkshatRaj00/visapredictor.git
cd visapredictor

python -m venv venv
venv\Scripts\activate

pip install -r requirements.txt

# Add Gemini API Key in app.py
GEMINI_API_KEY = "your_key_here"

streamlit run app.py

Deployment

Hosted on Streamlit Cloud
Easily deployable on any cloud platform

Impact & Use Cases

Students planning international education
Professionals applying for work visas
Immigration consultants and agencies
Data-driven travel planning

Future Enhancements

Real-time API integration with embassy data
Deep learning models for higher accuracy
Multi-language support
Mobile application version
Dashboard analytics for agencies

About the Developer

Akshat Raj is an AI Engineer and Founder of OnePersonAI, focused on building intelligent, human-centric systems that integrate machine learning with real-world applications.

Connect

Portfolio: https://onepersonai.in
GitHub: https://github.com/AkshatRaj00

Keywords

Akshat Raj AI Engineer, Visa Prediction System, Machine Learning Project, AI India, OnePersonAI, Streamlit AI App, Visa Processing Predictor

VisaIQ — AI-Powered Visa Processing Intelligence System

Akshat Raj — Fri, 03 Apr 2026 19:51:30 +0000

Built by Akshat Raj | Founder of OnePersonAI

VisaIQ is an advanced machine learning system designed to predict visa processing timelines with high accuracy while delivering AI-powered insights for smarter decision-making.

This project combines predictive modeling with real-time AI analysis to transform how individuals and organizations understand visa workflows.

Live Application

https://visapredictor-upltsgqphxttgzdnzheset.streamlit.app/

Overview

Key Features

Predict visa processing time using trained machine learning models
Generate confidence scores and processing ranges
AI-powered insights using Google Gemini
Support for custom dataset uploads (CSV-based training)
Clean and responsive user interface
Real-time results with minimal latency

Problem Statement

Visa applicants often face uncertainty regarding processing timelines, leading to poor planning and decision-making. Existing tools lack predictive intelligence and contextual understanding.

VisaIQ addresses this gap by providing data-driven predictions combined with AI-generated insights.

Technical Architecture

Frontend: Streamlit (Interactive UI)
Machine Learning: Scikit-learn (Random Forest, Gradient Boosting)
AI Layer: Google Gemini 1.5 Flash
Data Processing: Pandas, NumPy
Deployment: Streamlit Cloud

How It Works

Upload historical visa data (CSV format)
Train a machine learning model dynamically
Input country and visa type
Get predicted processing time
Receive AI-generated insights for better decision-making

Sample Dataset Format

country,visa_type,application_date,decision_date
India,Student,2024-01-10,2024-02-14
USA,Work,2024-03-01,2024-04-20
UK,Tourist,2024-06-15,2024-06-30

Local Setup

git clone https://github.com/AkshatRaj00/visapredictor.git
cd visapredictor

python -m venv venv
venv\Scripts\activate

pip install -r requirements.txt

# Add Gemini API Key in app.py
GEMINI_API_KEY = "your_key_here"

streamlit run app.py

Deployment

Hosted on Streamlit Cloud
Easily deployable on any cloud platform

Impact & Use Cases

Students planning international education
Professionals applying for work visas
Immigration consultants and agencies
Data-driven travel planning

Future Enhancements

Real-time API integration with embassy data
Deep learning models for higher accuracy
Multi-language support
Mobile application version
Dashboard analytics for agencies

About the Developer

Akshat Raj is an AI Engineer and Founder of OnePersonAI, focused on building intelligent, human-centric systems that integrate machine learning with real-world applications.

Connect

Portfolio: https://onepersonai.in
GitHub: https://github.com/AkshatRaj00

Keywords

Akshat Raj AI Engineer, Visa Prediction System, Machine Learning Project, AI India, OnePersonAI, Streamlit AI App, Visa Processing Predictor

Show HN: OnePerson AI — AI workspace for small businesses

Akshat Raj — Mon, 30 Mar 2026 23:57:08 +0000

🚀 Introducing OnePerson AI — I built this alone, from scratch.

No team. No funding. Just me and a vision to help small businesses in India.

OnePerson AI is an AI-powered workspace for small businesses:
✅ Billing & Invoice Automation
✅ Customer Support
✅ Inventory Management
✅ Business Reports & Analytics

Right now the platform is LIVE — and I'm building every feature myself, step by step. 🔧

This is for every shop owner, cafe, wholesaler, and solo founder who is tired of doing everything manually.

Day 1. Building in public. Watch me. 👀

🌐 onepersonai.in

OnePerson AI #StartupIndia #BuildInPublic #SoloFounder #SmallBusiness #AI #MadeInIndia #IndianStartup #Entrepreneur #BusinessAutomation

🚀 Introducing OnePerson AI — I built this alone, from scratch.

Akshat Raj — Mon, 30 Mar 2026 23:47:41 +0000

🚀 Introducing OnePerson AI — I built this alone, from scratch.

No team. No funding. Just me and a vision to help small businesses in India.

OnePerson AI is an AI-powered workspace for small businesses:
✅ Billing & Invoice Automation
✅ Customer Support
✅ Inventory Management
✅ Business Reports & Analytics

Right now the platform is LIVE — and I'm building every feature myself, step by step. 🔧

This is for every shop owner, cafe, wholesaler, and solo founder who is tired of doing everything manually.

Day 1. Building in public. Watch me. 👀

🌐 onepersonai.in

OnePerson AI #StartupIndia #BuildInPublic #SoloFounder #SmallBusiness #AI #MadeInIndia #IndianStartup #Entrepreneur #BusinessAutomation

Small Language Models (SLMs) vs Large Language Models (LLMs)

Akshat Raj — Fri, 13 Feb 2026 07:55:59 +0000

Abstract

The last five years have seen explosive progress in large language models (LLMs) — exemplified by systems such as ChatGPT and GPT-4 — which deliver broad capabilities but at heavy computational, latency, privacy, and cost budgets. In parallel, a renewed research and engineering focus on Small Language Models (SLMs) — compact, task-optimized models that run on-device or on constrained servers — has produced techniques and models that close much of the gap while enabling new applications (on-device inference, embedded robotics, low-cost production). This article/review compares SLMs and LLMs across design, training, deployment, and application dimensions; surveys core compression methods (distillation, quantization, parameter-efficient tuning); examines benchmarks and representative SLMs (e.g., TinyLlama); and proposes evaluation criteria and recommended research directions for widely deployable language intelligence. Key claims are supported by recent surveys, empirical papers, and benchmark studies.

Introduction & Motivation

Large models (billions to hundreds of billions of parameters) have pushed capabilities for zero-shot reasoning, instruction following, and multi-turn dialogue. However, their deployment often requires large GPUs/TPUs, reliable cloud connectivity, and high inference cost — constraints that hinder low-latency, private, and offline applications (mobile apps, robots, IoT). Small Language Models (SLMs) are intentionally compact architectures (ranging from ~100M to a few billion parameters) or compressed variants of LLMs designed for on-device or constrained-server inference. SLMs are not merely “smaller copies” of LLMs: the field now includes architecture choices, fine-tuning regimes, and tooling (quantization, distillation, pruning) that produce models tailored for specific constraints and use-cases. Recent comprehensive surveys document this growing ecosystem and its practical impact.

Definitions & Taxonomy

LLM (Large Language Model): Very large transformer-based models (≥10B params typical) trained on massive corpora. Strengths: generality, emergent capabilities. Weaknesses: cost, latency, privacy exposure.

SLM (Small Language Model): Compact models (≈10⁷–10⁹+ params) or aggressively compressed LLM variants that aim for high compute/latency efficiency while retaining acceptable task performance. SLMs include purpose-built small architectures (TinyLlama), distilled students (DistilBERT style), and heavily quantized LLMs.

Compression & Efficiency Methods: Knowledge distillation, post-training quantization (GPTQ/AWQ/GGUF workflows), pruning, low-rank/adapters (LoRA), and mixed-precision training.

Core Techniques that Make SLMs Practical 3.1 Knowledge Distillation

Technique: a large teacher model supervises a smaller student to transfer behavioral knowledge (soft labels, intermediate representations). DistilBERT demonstrated early that pre-training-level distillation can retain ~97% of performance at much lower cost — a paradigmatic result for compressed language models. Distillation remains foundational for creating high-quality SLMs.

3.2 Post-training Quantization & Low-bit Inference

Quantization maps floating-point weights to lower-bit representations (INT8, INT4, or custom schemes). Modern methods such as GPTQ enable high-accuracy quantization of large transformer weights with low computation time, making model weights small enough to fit on consumer GPUs and even enabling efficient CPU inference in some cases. Quantization is a cornerstone for running strong SLMs on constrained hardware.

3.3 Architecture & Pretraining Choices

Design choices (parameterization, attention variants, tokenizer design, training corpus quality) materially affect how well small models scale. TinyLlama demonstrates that careful pretraining can yield a compact model (≈1.1B) with competitive downstream performance by leveraging architecture optimizations and modern training recipes.

3.4 Parameter-Efficient Fine-Tuning (PEFT)

LoRA and adapter-style approaches allow small incremental updates to large base models (or small models) to add task specialization without full fine-tuning. For SLMs, PEFT enables rapid adaptation with tiny storage and compute budgets.

Benchmarks & Empirical Landscape

The comparison between SLMs and LLMs is empirical and depends strongly on the task. Recent benchmark studies focused on “small” models (SLM-Bench and other recent evaluations) reveal that many SLMs—when trained or distilled with modern recipes—achieve near-LLM performance on a wide range of tasks while using a small fraction of resources. These evaluations show that:

For classification and retrieval-style tasks, optimized SLMs often reach parity with much larger models.

For multi-step reasoning, chain-of-thought, or tasks requiring broad world knowledge, LLMs still lead — but gap shrinks when SLMs incorporate tool-use or retrieval augmentation.

Benchmarks that measure latency, memory footprint, and cost consistently favor SLMs for production-constrained settings.

Comparative Analysis (SLM vs LLM) Dimension Small Language Models (SLMs) Large Language Models (LLMs) Inference cost Low (edge/CPU/low-GPU) High (multi-GPU/cluster) Latency Low — good for interactive apps Higher unless heavily engineered Privacy Stronger (on-device) Weaker (cloud) Generalization & Emergence More limited Stronger emergent behaviors Updatability Easier for frequent updates More expensive to re-train/update Suitability Mobile apps, robotics, embedded systems, offline tools Research, broad assistants, heavy reasoning tasks

Bottom line: choose SLMs when constraints (cost, latency, privacy, offline operation) dominate. Choose LLMs when best-in-class general reasoning and broad knowledge are required.

Small Language Models (SLMs) vs Large Language Models (LLMs)

Akshat Raj — Fri, 13 Feb 2026 07:34:39 +0000

Towards Efficient, Reliable, and Deployable Language Intelligence at the Edge

Authors: Parth (Akshat Raj) — Draft for submission / public distribution
Date: Feb 13, 2026 (Asia/Kolkata)

Abstract

Introduction & Motivation

Definitions & Taxonomy

Compression & Efficiency Methods: Knowledge distillation, post-training quantization (GPTQ/AWQ/GGUF workflows), pruning, low-rank/adapters (LoRA), and mixed-precision training.