Reverse engineering · case study

How to read
a black box

A SaaS product only shows the part it chooses to show. Before building anything on top of it, I wanted to know what is really inside and where my right to look ends. This is the method, the numbers and the limits of an exercise carried out solely on the public surface of a product in production.

133JS files downloaded
20,201nodes in the semantic graph
290requests observed without a session
53product modules mapped

0 credentials · 0 backend access · 0 third-party data

01

The problem: deciding blind

A vertical SaaS presents itself with a simple promise and a handful of marketing screens. But the question that really matters —what does this do inside, and what doesn't it do?— isn't answered by looking at the landing page. And without that answer, every product decision is made on instinct: either you rebuild the whole thing, or you commit to the tool without knowing how far it goes.

Reverse engineering solves exactly that: reading what the product already hands to any visitor and turning it into a map. It isn't an end in itself; it's an instrument for making better decisions.

02

The rules of the game

Before the first line of code, a written boundary. It isn't a formality: the whole method depends on respecting it, because what makes the exercise useful is precisely what it leaves out.

In scope

  • The HTML and assets the browser downloads when it opens the site
  • The language dictionaries served as public JSON
  • The traffic generated by an anonymous visit to the login page
  • Public documentation and support material

Out of scope

  • The backend, its protected endpoints or its infrastructure
  • Any attempt to bypass authentication or authorization
  • Customer, account or third-party data
  • Social engineering, brute force or exploiting vulnerabilities
03

The method, in five moves

1

Copy the surface

One request to the login page and its list of assets. No session, no cookies, exactly what any visitor receives.

↓ 133 JS files · 3.5 MB · 1 CDN
2

Static reconnaissance

A search for hosts, routes, service names and domain vocabulary. The code is minified, but the text isn't: it survives intact.

↓ stack, third parties and ~20 client API routes
3

Semantic graph

A parser turns the bundle into a graph of functions, calls and literals. It's narrowed down to two files: the entry and a domain chunk.

↓ 20,201 nodes · 16,673 relations · 1,432 functions
4

Anonymous traffic

A headless browser opens the login page and records the network. The 401 response isn't an error: it's the boundary of the system, confirmed.

↓ 290 requests · 2 real endpoints · header auth
5

Product dictionaries

The translation files are public and work as an inventory: every module, every screen and every feature has its name there.

↓ 106 files → 53 product modules
·

Why in this order

Each step narrows the target of the next. Downloading everything first and analyzing it afterwards would have been unworkable: the full graph of 133 files runs to hundreds of megabytes.

↓ narrow before analyzing
04

The finding: the product was bigger than the promise

The marketing sells one feature. The dictionaries describe 53 modules: purchasing, recipe costing, inventory, sales, treasury, payroll, group consolidation, bank reconciliation, accounting. What is presented as a single-purpose tool is, inside, a complete vertical ERP.

That gap between the message and the product is the most valuable finding of the exercise: it defines the real gap in the market and, at the same time, warns you what makes no sense to rebuild.

Costs and purchasing

15
documentspurchasingpending orders suppliersproductscategories dishes and recipe costingmenusmodifiers unitsinventoryinventory v2 incidentsreconciliationgroup recipe costing

Finance

4
bankingtreasury paymentssubscriptions

Sales

2
salesgroup sales

People

1
payroll

Group and holding

10
group homedocumentsexpenses P&Lproductssales supplierstreasuryshared holding

Platform

21
accessactivationpermissions rolesonboardingnotifications integrationslanguagessettings supporthomedashboard whatsappformsalerts glossarywhat's newcommon empty statescancellationsportal
53 / 53 modules classified into 6 areas source: public language dictionaries
05

What this method doesn't do

A case study that only tells what went well teaches nothing. These are the walls I ran into, and why the result is still useful in spite of them.

The result wasn't a finding, it was a decision

The map is there so you don't repeat work

Knowing that the product already covers 53 modules changes the strategy completely. Rebuilding what already exists at a low subscription price is the worst possible investment. The gap is in what the product doesn't do —forecasting, reputation, team training, a unified dashboard— and in the layer that connects it all.

The outcome of the exercise isn't code: it's a perimeter. And with a clear perimeter, the work that's left is the work nobody else is doing.

The rule I take away: if there's already a SaaS that does it for ~€200 a month, don't build it — integrate it.