SheetSense: Making Sense of Excel Workbooks Nobody Wants to Inherit

This is my submission for Hacktoberfest Open-Source AI Challenge — Week 2: Side Hustle.

The idea behind SheetSense

We've all seen files like pricing_FINAL_v7_use_this_one.xlsx.

The person who created it is long gone. Nobody knows why certain formulas exist, which cells are safe to edit, or whether the numbers at the bottom are even correct. But the business still depends on that spreadsheet, so everyone keeps using it.

I wanted to build something that could help with that situation.

SheetSense takes an existing Excel workbook and helps you understand how it works, where things might be wrong, and how its numbers are connected. It runs locally, so the workbook doesn't need to leave your machine.

Here's what it does:

• Explains the workbook: Get a plain-English overview of each sheet and its purpose.
• Finds suspicious formulas: Flags things like hardcoded values inside formulas, inconsistent formula patterns, and SUM ranges that might be missing data.
• Maps dependencies: See how sheets and cells feed into one another.
• Answers questions: Ask something like "Where does the final margin come from?" and trace the answer back to the relevant cells.

The goal isn't to replace Excel or tell people to blindly trust another tool. It's to make an unfamiliar workbook easier to investigate.

Who is this for?

I had a few people in mind while building this: an accountant taking over a new client's books, a small business owner trying to understand a pricing model, or an operations analyst who has just inherited a spreadsheet that nobody else wants to touch.

Their problem isn't necessarily that Excel is difficult to use. It's that understanding someone else's spreadsheet can take far longer than building your own.

You can trace formulas manually, compare hundreds of rows, or ask the previous owner for help. Sometimes that person is still around. Sometimes they left two years ago.

And unlike a program that crashes when something breaks, a spreadsheet with a wrong formula can keep producing believable numbers for months without anyone noticing.

That's the problem I wanted to tackle.

Why not just use a chatbot?

You could paste formulas into a chatbot and ask it to explain them. For a small spreadsheet, that might be enough.

The problem gets harder when you're dealing with a workbook containing thousands of formulas across multiple sheets.

A pasted formula doesn't give a chatbot the complete dependency structure. Finding one formula that differs from hundreds of similar formulas requires systematic comparison. And if the workbook is too large to fit into the context, important relationships can get lost.

There's also the privacy issue. Client workbooks can contain financial information, payroll data, and internal pricing.

I wanted SheetSense to approach this differently: let code inspect the actual workbook, build its structure, and identify issues. Use an LLM only when a natural-language explanation is useful.

That distinction shaped almost every technical decision I made.

How I built it

The central rule behind the project was simple:

Code finds the facts. The model explains them.

Here's how the analysis works.

1. Read the workbook. openpyxl extracts formulas and available cached values from the Excel file.

2. Resolve formula references. Formulas are tokenized to identify the cells and ranges they depend on, including references across sheets and absolute references.

3. Build the dependency graph. A directed graph in networkx connects precedent cells to the cells that depend on them. This makes it possible to trace how a value moves through the workbook.

4. Compare formula patterns. Each formula is normalized into a relative form. For example, =B5*C5 and =B6*C6 represent the same pattern even though they appear on different rows. This lets SheetSense group repetitive formulas and identify cells that break the pattern.

5. Run deterministic checks. Rules flag suspicious hardcoded constants, formula inconsistencies, potentially incomplete SUM ranges, unused inputs, error values, circular references, and unit mismatches. These findings come from code and predefined templates, not from an LLM guessing what might be wrong.

6. Generate explanations. A local Gemma model, served through Ollama, receives small bundles of verified facts and returns structured JSON explanations.

7. Answer questions with traceable evidence. When someone asks a question, the application traces the relevant dependency chain first. The model explains that chain, and cited cells are validated against it. Citations outside the traced chain are rejected.

The application itself uses FastAPI, SQLite, React, and Vite, with analysis progress streamed to the interface.

The important part is that the LLM doesn't get to decide whether a formula is incorrect or invent a dependency graph. Those responsibilities stay with the code.

Why run the model locally?

Local inference wasn't added just because running an LLM locally is interesting. It addresses a practical concern with this particular application.

Privacy: Workbooks containing client finances or internal business figures don't need to be uploaded to a hosted AI service. The analysis and inference can run on the same machine.

Cost: A large workbook may require many small explanation calls. Using a paid API for every call could make the service expensive to operate. Local inference avoids a per-request model API bill, although it still uses the machine's processing power and electricity.

Flexibility: Gemma is configurable through the application settings. The model can be changed without redesigning the workbook-analysis pipeline.

Offline use: Once the required dependencies and model are installed, SheetSense can analyse workbooks without an internet connection.

There are trade-offs, though. Smaller local models can produce weaker explanations, and they can still get things wrong. Local inference also requires suitable hardware and an installed model.

That's why I didn't make the model responsible for the underlying analysis. The formulas, dependency graph, and deterministic findings remain available as evidence for its explanations.

Local AI is useful here, but only because the rest of the system doesn't depend on the model being right about everything.

Turning it into a side hustle

For this challenge, I also wanted to think beyond building something technically interesting.

I see three possible ways to offer SheetSense as a service:

• Workbook handover reports: A one-time report documenting a workbook's structure, dependencies, and potential issues for an accountant, consultant, or small business.
• A packaged desktop application: A version for professionals who regularly inherit and review client spreadsheets.
• Freelancer-friendly pricing: A lower-cost alternative for people who don't need a full enterprise financial-modelling audit platform.

The value proposition is straightforward: if someone spends hours understanding a workbook, or misses a formula error that affects a business decision, a tool that helps reduce that work could be worth paying for.

But there's an important distinction between a possible business model and a validated one. I haven't tested these pricing ideas with paying customers yet. Finding accountants and small businesses willing to try SheetSense, then learning what they'd actually pay for, is the next step.

Code

PIYUSH-NEXTGEN / Sheet-Sense

Spreadsheet Inheritance Translator

SheetSense: Spreadsheet Inheritance Translator

SheetSense helps you understand Excel workbooks that someone else created and nobody fully understands anymore.

Think of a file named pricing_FINAL_v7_use_this_one.xlsx. The person who built it has left, the formulas have barely been documented, and nobody knows which cells can be safely edited. The spreadsheet still runs the business, so replacing it is not an option.

SheetSense helps you investigate that workbook without having to trace every formula manually.

It generates a plain-English overview of each sheet, flags suspicious cells for review, maps dependencies between sheets, and lets you ask questions about where a number comes from. It also exports a Markdown report that can be used when handing the workbook over to someone else.

The entire analysis runs locally. Your workbook does not need to be uploaded to an external service.

Code finds the facts. A local language model explains them.

What SheetSense does

…

View on GitHub

Why open innovation matters here

I think open-source AI is particularly useful for projects like SheetSense because the model doesn't have to be the entire product.

The workbook parser, formula analysis, dependency graph, and detection rules do most of the important work. The language model makes the results easier to understand.

Keeping those responsibilities separate means developers can inspect the logic, test it without a model, replace the model, and improve individual parts without rebuilding the whole application.

It also makes the limitations easier to explain. A suspicious formula isn't automatically proof of an error, and an LLM-generated explanation isn't automatically correct. Users still need to review the underlying evidence.

For a tool dealing with financial spreadsheets, that distinction matters.

Prize categories

GEMMA