Free GST Billing Software Puts a Web Server on Your Laptop

India's smallest businesses get a subscription-free invoicing app that never leaves their machine. The hard part isn't the tax math. It's surviving a computer you'll never see.

9 min read • View on GitHub • More from IamRamgarhia

A night-time editorial illustration of a small Indian kirana shop lit by one hanging bulb, with an open laptop glowing on the wooden counter. On the laptop screen sits a tiny server rack and a stack of ledger books enclosed by a low brick wall, while faint cloud servers and subscription invoices float outside the wall in the shadows. It visualizes the article's thesis that this invoicing app keeps all data inside a walled garden on the user's own machine.
The whole product in one frame: a shop, a laptop, and a walled garden where the cloud economy cannot reach.

Introducing a free GST Billing Software — an open-source, offline-first PWA. There are no subscriptions, no signups, and your data remains on your machine.

Matinderpal Singh, Founder, Dice Codes · LinkedIn announcement
Key Takeaways

A shopkeeper in a small Indian town opens a laptop, types an invoice number, and hits save. Nothing leaves the machine. No account, no cloud, no monthly fee. That is the whole pitch, and underneath it sits a surprisingly hard engineering problem.

The App That Runs a Server on Your Laptop

Under the hood, Free GST Billing Software is not really a desktop program. It is an Express server bound to localhost, serving a React single-page app that installs as a progressive web app. The desktop wrapper is a costume, and the costume is the point.

Everything the user creates lands in JSON files under a data folder on their own disk. The server defaults to port 47371, chosen to avoid the crowded 3000 range, and persists the choice to data/port.txt so the app reopens where it left off.

The frontend ships React 19 and Vite 7, with fourteen views loaded lazily and only two eager imports: the dashboard and the invoice generator. The primary action stays instant. Everything else loads on navigation. The whole bundle is roughly four megabytes of JavaScript.

Packaging shows the platform spread: an Inno Setup installer and a C# host for Windows, a .command launcher for macOS, AppImage and .deb builds for Linux, plus Docker and an HTA/PowerShell fallback. One developer maintains all of it.

The Day Localhost Stopped Being Safe

For most of the app's life, the server trusted every request. Express enabled CORS with app.use(cors()), which echoed Access-Control-Allow-Origin: * back to whoever asked.

That is normal when your origin is a domain you control. It is dangerous when your origin is localhost. Any website the user happened to visit could run fetch('http://localhost:47371/api/bills') and read every invoice on the machine, or wipe them.

// Replaces app.use(cors()), which echoed Access-Control-Allow-Origin: *.
// Any site the user visited could fetch('http://localhost:47371/api/bills')
// and read/wipe all data. Accept only same-origin or no-Origin requests.
app.use((req, res, next) => {
  const origin = req.headers.origin;
  if (!origin || origin === `http://localhost:${PORT}`) {
    if (origin) res.setHeader('Access-Control-Allow-Origin', origin);
    return next();
  }
  return res.status(403).end();
});

The replacement accepts only requests with no Origin header or an Origin of http://localhost:<port>. A browser tab on the open web now gets a 403. This is a security posture you would expect from a fintech infrastructure team, not a solo-maintained invoicing tool.

The same instinct shows up in the lock file. Two copies of the app on one machine would overwrite each other's JSON files, and JSON has no transactions to save you. So the server takes a lock recording its process id, host, and a random identity, and treats the lock as live only if a server answers on the recorded port with the matching identity. A stale lock from a crash is distinguishable from a running one.

One Developer, One Shopkeeper, One Subscription-Free Stack

The project comes from Matinderpal Singh, founder of Dice Codes, who maintains it under the handle IamRamgarhia. One contributor, one repository, no community fork wars.

The pitch aims straight at the smallest businesses in India: freelancers, kirana shop owners, traders, and consultants. The positioning names the tools it wants to displace: Tally, Vyapar, Zoho Books, myBillBook, ClearTax, and Marg. The license is MIT. The docs live on a Dice Codes site. There is no paid tier, no upsell, and no account.

A WSJ hedcut-style black ink portrait of the project's maintainer, rendered from the IamRamgarhia GitHub avatar with stipple shading and fine hatching on a pure white background.

Free GST Billing Software — Free, open-source GST invoice & billing software. Tax Invoice, Proforma, Credit Note, Bill of Supply. CGST/SGST/IGST. Multi-currency. 100% offline, no signup. PWA installable.

Project maintainers, Repository description · Repository description

Notice what the description repeats: no signup, installable, 100 percent offline. That is not a feature list. It is a stance about who owns the data.

The Twenty-Second Tightrope

A PWA has a problem no native app has. The frontend can change underneath a running session. Deploy a new build while a shopkeeper has an invoice half-typed, and the old HTML may reference JavaScript chunks the new deploy has deleted. The result is a white screen.

A close-up editorial illustration of a shopkeeper's face lit by laptop glow, one hand resting on the keyboard, with a half-typed GST invoice blinking on the screen. In the doorway behind him a ghostly second copy of the same application waits to step in, and a small wall clock reads 20 seconds. It makes the PWA update problem human before the reader sees the diagram of how it is solved.
The person the update strategy is protecting, seconds before the timer runs out.

The repo's answer is a layered update policy in src/main.jsx. When the service worker signals that a new version is ready, the app does not reload. It sets a flag and waits.

Then it checks the page. A helper called hasUnsavedInput() scans every input, textarea, and contenteditable element for non-empty values. If the view is read-only, the update applies after 500 milliseconds. If there is unsaved input, it waits 20 seconds.

That 20 seconds is the tightrope. It is long enough to finish a line, not long enough to guarantee nothing is lost. The code's own comment calls it enough to finish typing a line or two, then auto-apply. The design chooses never serving a broken bundle over never losing a draft.

Four more layers back it up: a blur listener applies a pending update when the tab loses focus, a migration path sends SKIP_WAITING to any waiting service worker left over from older versions, a window error handler catches failed dynamic imports and reloads once, and a boot marker tells the boot guard the app loaded cleanly.

Six layers of defense between a deploy and a shopkeeper's half-typed invoice.

How It Compares to the Tools It's Replacing

The project keeps its own competitor analysis in docs/COMPETITOR_GAPS.md, researched in April 2026. It is a first-party document, so read the table as the project's view of the field, not an independent audit.

ToolPrice modelDeploymentData locationOffline-firstIndia GST depthe-Invoice & GSTN filing
Free GST Billing SoftwareFree, MITLocal desktopUser's machineYesFullNative e-invoice JSON, filing on roadmap
TallyPrimeSubscriptionLocal desktopUser's machineYesFullNative connected IRN, direct filing
VyaparFreemiumMobile and desktopVendor cloudPartialFullPartial
Zoho BooksSubscriptionCloudVendor cloudNoFullAdd-on services
ERPNextFree, self-hostSelf-hostSelf-hostedPartialPartialNative IRN and QR, GSTN upload
Invoice NinjaFreemium, source-availableSelf-host or cloudSelf-hostedPartialNone nativeNot supported

The honest read: the free tool wins on cost and data ownership, and loses on depth. IRN generation, direct GSTN filing, and deep reconciliation are the expensive parts of compliance, and those are exactly where the paid products have spent years. The gap document also treats some features as missing that the README later advertises, which tells you the feature state moved between versions.

A Codebase That Keeps Its Own Incident Log

Most repositories hide their bug history in commit messages and closed issues. This one writes it into the source, version-tagged, next to the fix. The comments read like short incident reports.

// v1.10.2  Reported: data blown away on every deploy
// v1.10.33 Reported: "it work in incognito only"
// v1.10.35 Nuclear defensive path for the
//          "still white screen on refresh after v1.10.33" report

That is unusual, and it signals something about the maintainer's process. The failures are named, dated, and left in place for the next reader. You can trace the app's field life directly from the source, which is rare in a project this small.

What It Still Can't Do

The project is candid about its limits. The gap analysis lists these as roadmap items or acknowledged competitor advantages:

None of that diminishes the core claim. The tax invoice on the counter is real, the data is on the disk, and the bill is zero. For a freelancer or a one-person shop, that may be the whole job.