A declarative engine for diagnostic analytics.

You declare what to watch for in your data. jinflow builds it, runs it, explains it — and keeps the answers on your machine.

The jinflow.

jinflow fosters Progress by gaining Understanding through Observations, Knowledge, and Data. The sentence is the product, said once.

Analytics you declare, not program.

The entire analytical framework is human-readable declarations — versioned like source code, owned by the customer.

• Everything is a declaration — diagnostic queries, business questions, root-cause rules, pages, charts, tiles, maps. A new analytical perspective is a text file, not a software project.
• Form follows data — visualizations adapt to the shape of the data automatically; a time series gets a chart, a fleet gets a map.
• One command builds it all — validate, compile, run, report. Deterministic and reproducible from a single framework commit.

From raw data to “here is why — and what to do.”

jinflow doesn’t stop at dashboards. It climbs a reasoning ladder — and writes the answer in the reader’s language.

• Signals find what doesn’t fit — unbilled usage, duplicate records, silent sensors — each finding priced with money at risk.
• Theses weigh the evidence into plain-language answers to business questions: confirmed, plausible, not observed.
• Verdicts explain the root cause and recommend the action — process failure, system gap, stale master data.
• Tri-lingual by design — every interpretation reads natively in English, German, and French.

What the experts know becomes part of the system.

The knowledge no data model can derive — workarounds, quirks, history — is captured, attributed, and kept honest.

• Subject Matter — atomic expert statements with provenance: who said it, when, about what, and why it is so.
• Checkable — a statement can carry an executable check, so the system continuously verifies what the expert claimed.
• Dossiers curate the atoms into narratives — the story layer for handovers, audits, onboarding.

An entire analytical world in a single file.

Every build produces one self-describing knowledge store: the data, the findings, the interpretations — and the framework that produced them, travelling inside.

• Portable — copy it, ship it, open it anywhere; no server, no database cluster, no vendor account.
• Snapshot-able — freeze an immutable, timestamped copy at any decision point: this is what we knew, and how we knew it.
• Self-describing — the store carries its own build provenance and the complete source framework. An audit needs nothing else.

Your data. Your machine. Their browser.

Privacy is not a policy here — it is the architecture. Sensitive data can be analyzed, shared, and even AI-assisted without ever leaving the building.

• Local-first — the full product runs on one laptop, offline.
• Share without surrendering — viewers reach the analysis through a tunnel to your machine; unplug it and the data is gone from the internet, instantly.
• Cloud only where it belongs — non-sensitive showcases run always-on in the cloud; the choice is per tenant, not per product.

A built-in analyst — on the framework, never on the data.

Vera is jinflow’s conversational AI. For sensitive customers she works in structure-only mode — and that gate fails closed.

• Structure-only mode — unless a tenant is explicitly a public showcase, Vera reasons about the framework — signals, questions, schema — while no data row ever reaches the AI provider. Even an internal error resolves to the safe side.
• She proposes, humans decide — her framework drafts go to a staging area for review and publication; she can never write directly.
• She speaks — voice in, voice out; conversations persist in the customer’s own store.

You don’t read the data. You converse with it.

Point at anything, and the whole picture answers — across every panel, and across every window.

• Linked everywhere — brush a chart, click a site on the map, select dots on a scatter: tables, tiles, maps, and charts all re-scope together. Every view is a shareable URL.
• Connected windows — windows link into a constellation: one brush scopes them all, across monitors. Any panel detaches into its own chrome-less instrument window.
• Real cartography — geographic truth on real base maps, driven by the same selections.

Measurements, not just numbers.

Every value in the product knows what it is — its type, its unit, and the real-world standard behind it. The build refuses anything less.

• Semantic types on every column — quantity, identifier, time, category — with units and roll-up rules. Mis-typed data is a build error, not a surprise.
• Grounded in real standards — an in-product registry of industry standards (units, currencies, time, water quality, trade codes …), cited by the data that obeys them.
• Drill in two directions — down the organization’s hierarchy, and along the measurement’s refinement chain from raw reading to reported value.

Everything that happens is on the record.

jinflow is built for environments where “trust me” is not an answer.

• Data intake is a contract — every source file is declared, fingerprinted, verified on every run, and logged append-only.
• Every run is recorded — who started it, from where, phase by phase; failures carry their reason. Browse and replay any run, and watch anyone’s run live from any window.
• Every answer is reproducible — a knowledge store can always be rebuilt from the exact framework version that produced it.

Five industries. Seven live tenants. One engine.

Domain expertise ships as packs — starter kits a customer copies and then owns. Every tenant is an isolated world, down to its language.

• Running today — hospital material flow on real data, HR analytics, freshwater sensing, wine estate, freight forwarding.
• The pack seeds, the tenant owns — customers evolve their framework independently; the operator still sees fleet health at a glance.
• Even the words are governed — the UI marks which vocabulary every term belongs to, with a hover passport:

Platform

the engine’s nouns — identical everywhere

Pack

the domain’s words

Tenant

the customer’s own voice

Standard

the outside world’s rules

Near.

• The constellation grows — linked windows beyond one browser, and live run activity across the whole fleet in one view.
• An operational memory — a durable state-of-record for everything that happened, independent of any single machine.
• The fleet, modeled — the operator’s tenant population becomes explorable data: facets, cohorts, comparisons.
• The language, audited — a lint that lists every term no vocabulary claims, per tenant.

Horizon.

• Build in the cloud on push — the laptop becomes optional; publish is the build.
• One handshake for identity and license — a local install asks “who is this, and are they entitled?” and gets a signed answer.
• Showcases that announce themselves — declare a tenant public, and the cloud discovers, routes, and serves it.
• A doctor for the framework — advisory instruments on the analytics themselves: “I’ve seen this shape go wrong.”
• Packs that branch and share skills — graftable modules, and analytical patterns that travel between domains.