Local-first analytics

Analyze the spreadsheet you are not allowed to upload.

Statistics and charts for Excel and CSV files, computed entirely inside your browser tab. The file never leaves your machine.

There is no upload step, because there is no server to upload to. Your browser opens the file, runs Python on your own CPU, and draws the charts. Close the tab and nothing is left anywhere.

Open PRISM in your browser Check the claim first
  • No account
  • No email address
  • Nothing to install

Network activity on this page

Resource Timing API

0 requests since this page loaded

No request for 0s

Everything this page has fetched

  1. Reading the browser timing buffer.

This panel needs JavaScript to read your browser's own timing buffer. Without it, use the DevTools Network panel instead. That is the more trustworthy instrument anyway, for the reason given below.

Do not trust this counter. It is our number, rendered by our script, on our page. It also cannot see WebSocket connections, because the Resource Timing API does not record them. Your DevTools Network panel has neither limitation. Open it and compare.

01

Do not trust this. Measure it.

Every analytics vendor says your data is safe. You cannot check any of them, which is why your privacy office reviews the contract instead of the software. PRISM makes a narrower claim on purpose: one you can falsify yourself, in about two minutes, without our participation and without telling us you did it.

  1. Watch the network panel stay empty

    Open DevTools, go to the Network panel, tick Disable cache, and load PRISM. You will see the application and the Python runtime download. Then drop in your file and run the analysis. Nothing further appears. No request, no beacon, no socket.

  2. Pull the plug

    Load the page, then disconnect from the network entirely. Turn off Wi-Fi, unplug the cable. Now drop in the file. The analysis still runs. A tool that needed a server could not do that, and no amount of marketing can fake it.

  3. Read the policy the browser enforces

    PRISM ships a Content Security Policy in its page source. This is not a promise in our code that our code could later break. It is a restriction your browser applies to the page, whether we like it or not.

    Content-Security-Policy, verbatim from PRISM's page source 
    default-src  'none';
script-src   'self' 'wasm-unsafe-eval' https://cdn.jsdelivr.net/pyodide/ https://cdn.sheetjs.com/;
connect-src  'self' https://cdn.jsdelivr.net/pyodide/;
worker-src   'self' blob:;
img-src      'self' data: blob:;
font-src     'self' data:;
form-action  'none';
object-src   'none';
frame-src    'none';
base-uri     'self';

    default-src 'none' denies everything, then each line grants back one narrow thing. The line that matters is connect-src. It permits exactly two destinations: PRISM's own origin, and the CDN path that delivers the Python runtime. There is no third. form-action 'none' means the page cannot submit a form anywhere, to anyone, ever.

  4. Grep the source for the ways out

    A browser page has four ways to send data somewhere: fetch, XMLHttpRequest, WebSocket and navigator.sendBeacon. Search the source for all four.

    Run this against the repository 
    grep -rnE "fetch\(|XMLHttpRequest|WebSocket|sendBeacon" src/

    Here is what comes back, stated before you find it yourself. There is no XMLHttpRequest, no WebSocket and no sendBeacon anywhere in the source. There is exactly one live fetch, in src/workers/prism.worker.js, and it downloads the Pyodide runtime from the CDN named in the policy above. It runs once, at startup, before your file is involved, and each artifact it retrieves is pinned to a SHA-384 digest that the browser itself verifies, so a compromised CDN cannot substitute different code. The remaining matches are those words appearing in a code comment and in the test that asserts none of them are used.

    That test is in the repository. src/stores/prismStore.test.ts reads the worker's own source and fails the build if a WebSocket, XMLHttpRequest or sendBeacon call ever appears in it.

Where the claim stops

This is a claim about PRISM's code and your browser's enforcement of its policy. It is not a claim about your whole machine. A malicious browser extension, a compromised endpoint or a keylogger can read anything on your screen, and that is true of every web application and most desktop ones. We cannot fix your endpoint and we are not going to pretend otherwise.

PRISM has also not had an independent third party review this architecture. When it does, the report gets published, including whatever it finds.

02

Three steps, all of them inside your tab

The architecture is the product. There is no clever part, and that is the point. Every component is mature, boring, and running on your own hardware.

Your browser tab

  1. The file is opened, not uploaded

    You drop an .xlsx, .xls or .csv file onto the page. SheetJS parses it in the tab, using the browser's File API. The bytes go from your disk into the tab's memory and nowhere else.

    SheetJS, main thread

  2. Python runs on your CPU

    Pyodide runs CPython compiled to WebAssembly inside a Web Worker. pandas, NumPy and SciPy execute there, on your machine, off the main thread so the interface stays responsive. This is the same library stack a data scientist would run locally.

    Pyodide, WebAssembly, Web Worker

  3. Results are drawn back into the page

    Column types, descriptive statistics, outlier, trend and correlation flags, and the charts the data supports. Seventeen statistical tests are wired to scipy.stats, from Shapiro-Wilk to two-way ANOVA. Close the tab and all of it is gone.

    Recharts, main thread

Enforced by the browser

  • default-src 'none'
  • connect-src 'self' https://cdn.jsdelivr.net/pyodide/
  • form-action 'none'

One connection leaves, once, at startup. The Web Worker downloads the Pyodide runtime from the CDN named in the policy, with every artifact pinned to a SHA-384 digest the browser verifies before executing it. That happens before your file is opened. After it, there is no permitted destination left for your data to go to.

One detail worth the paragraph. A Web Worker created from a network URL takes its policy from that script's own HTTP response headers, not from the page. PRISM builds its worker from a blob: URL instead, which is a local scheme, so the worker inherits the document's policy rather than running without one. The worker is where your data actually lives, so this is the difference between a policy that covers the data and a policy that covers the shell around it. It is asserted by a test in src/stores/prismStore.test.ts.

03

Who this is for

One situation, in several industries. You have the file, you have the question, and the tool that would answer it in ten minutes is the one tool you are not permitted to put the file into. The problem was never the analysis. The problem is the upload.

Built for

  • Audit and assurance. Profiling a client general ledger extract or a sampling population before fieldwork, on an engagement where the data cannot go to a vendor you did not put through third-party risk.
  • Healthcare analytics. An identifiable extract that would need a business associate agreement, or a privacy impact assessment, before it could touch a cloud tool.
  • Legal and eDiscovery. Counts, date ranges and custodian distributions on a production under a protective order, where the order names who may hold the data.
  • Public sector and residency-constrained work. Analysis that cannot legally cross a border, on a laptop where you have no rights to install software and no time to request them.
  • Anyone whose first question about a new tool is where the data goes, and who would rather check than be told.

Not built for

  • Shared dashboards that a team opens and a schedule refreshes.
  • Warehouse or database connections. PRISM reads files, nothing else.
  • Multi-user permissions or row-level security.
  • Collaboration. Nothing is saved, so there is nothing to share.
  • Datasets larger than your machine's memory can comfortably hold.

These are not gaps on a roadmap. They are what was traded away. Every one of them needs the server PRISM deliberately does not have, and adding that server would delete the only reason to choose PRISM.

If you need any of them, use a business intelligence platform and use it without apology. Use PRISM for the first ninety minutes with a new file, before anyone has decided whether it deserves a dashboard.

If you already have a local tool, use it

Power BI Desktop and Tableau Desktop also run on your machine. If one is already installed and approved on your laptop, that is a real alternative and you should consider it first. The honest edge PRISM has over them is install friction: PRISM is a web page, so it works on a locked-down client machine where you cannot install anything and cannot wait for a request to clear.

The same applies to Excel. PRISM reads the file Excel gave you and tells you in one pass what is in it, so you know where to look when you go back. It is a profiling step in front of Excel, not a replacement for it.

04

What is wrong with PRISM today

Written by us, before you find it. PRISM is early and pre-revenue. What is proven is the architecture, and you can confirm that yourself in two minutes. Everything a mature product earns over time has not been earned yet, and the list below is what that means in practice as of 13 September 2026.

  • Closed

    The spreadsheet parser advisory is remediated

    PRISM used to depend on xlsx@0.18.5, which carries a high severity prototype pollution advisory (GHSA-4r6h-8v6p-xvw6) that npm reports as fixAvailable: false, because SheetJS moved distribution off npm and the registry copy is frozen at the vulnerable version.

    It is gone. SheetJS 0.20.3, which fixes both that advisory and the ReDoS one, is vendored at public/vendor/ and loaded on demand with an SHA-384 integrity hash. npm audit no longer reports xlsx at all. Vendoring rather than using the CDN keeps Excel parsing working offline and let us remove cdn.sheetjs.com from the Content-Security-Policy entirely. Check it: grep xlsx package.json returns nothing.

  • Not verified

    The statistics are not yet proven correct

    A test suite is being built now and part of it exists, including the test that guards the no-egress property. What does not exist yet is coverage that validates the seventeen statistical tests against known answers. Until it does, you will not find the words accurate, validated or production ready anywhere in our material, and you should not infer them.

    Three specific defects are known and recorded: charts truncate to the first N rows rather than sampling, one group comparison silently uses only the first two groups it finds, and only the first worksheet of a workbook is read. The last of those is the most likely way PRISM gives you a confidently wrong answer today.

  • Unmeasured

    There is a file size ceiling and we will not guess at it

    A browser tab has a memory ceiling and PRISM holds the parsed data inside it. A real limit exists. No number is published here because nothing has been benchmarked honestly. MAX_FILE_SIZE is set to 500 MB, but that constant is an upload guard, not a measured capability: nobody has established the size at which a tab actually degrades. Once the benchmark exists it will be published with the method, the machine and the browser stated, along with the point at which it degrades.

    Until then: PRISM is built for the everyday analytical extract, the file that arrived by email or came out of a warehouse query. If your file is larger than the tab can hold, the right answer is not PRISM.

  • Being corrected

    The README claims two things nobody has verified

    The repository README currently asserts WCAG 2.2 Level AAA and ISO/IEC 27001:2022. There is no accessibility audit and no information security management system behind either claim, so both are being removed. What is true is narrower and still worth saying: PRISM is designed against WCAG 2.2, with keyboard navigation, screen reader data tables, chart sonification and a high contrast mode built in. Independent audit not yet performed.

  • Closed

    The licensing now says one thing

    The LICENSE file and package.json both read MIT. They used to disagree, with package.json declaring PROPRIETARY over an MIT licence file. An MIT grant is binding and irrevocable for every copy already distributed, so declaring otherwise elsewhere did not retract it: it only made the repository assert two incompatible things at once.

    PRISM is MIT licensed today. Whether it stays permissive or moves to a source-available licence is an open commercial question and is not settled here. Any change applies to future releases only.

  • By design

    There is no telemetry, so we know nothing about you

    No analytics, no error reporting, no crash traces, no session, no account. This is a feature for you and a real cost for us. We cannot see that a feature confused you, we cannot count anything, and we will never have usage numbers of the usual kind. If something breaks, we learn about it only if you tell us.

  • By design

    The runtime still comes over the network, once

    The page is served to your browser from somewhere, and the Python runtime is downloaded from a CDN the first time you use it. Both happen before your file is involved, and every runtime artifact is verified against a pinned SHA-384 digest before it executes. If your environment requires it, load the page, disconnect, then work.

  • Stated plainly

    Nobody is using it yet

    PRISM is pre-revenue with no customers. If you adopt it, you are first. There is no pipeline to gesture at and no case study to send you. You would be deciding on the architecture and on what you can verify yourself, which is the only basis we would want you to use anyway.

05

Who built it

PRISM is built by Jesun Ahmad Ushno, an AI engineer and data architect in Toronto.

He spent his earlier career in KPMG IT Advisory, running ISO 27001 engagements in banking and healthcare. That work is the reason this product exists and the reason it is shaped the way it is. An audit does not ask whether you intend to protect the data. It asks whether you can demonstrate where the data went. PRISM is designed against that question, and the answer is nowhere, evidenced by a policy your own browser enforces rather than by a paragraph in a privacy notice.

That is biography, not endorsement. KPMG has no involvement in PRISM, has not reviewed it, and does not endorse it. PRISM holds no certification of any kind.

Open the file you have been carrying around

No account, no email address, nothing to install, no trial to expire. It is a web page. Open it, drop the file in, and close the tab when you are done.

Open PRISM in your browser Read the source

There is no signup form on this page. Not as a growth tactic, and not because we forgot. A page arguing that it sends nothing anywhere has no business asking for your email address to prove it.