Why Excel Fails at Expiry Tracking — And What to Use Instead

Excel is excellent at many things. Expiry tracking is not one of them.

Let's be honest about something: Excel is one of the most powerful tools ever created for business. It handles financial modelling, data analysis, reporting, budgeting, and a thousand other tasks with remarkable flexibility. Millions of businesses run critical operations on spreadsheets, and many of them run well.

But there's a category of problem that Excel was never designed to solve, and expiry tracking is squarely in it. Not because Excel can't store expiry dates — it can. Not because you can't build formulas to calculate days remaining — you can. The failure is more fundamental than that. Expiry tracking requires a system that is proactive, multi-user, real-time, mobile-accessible, and integrated with the point of sale. Excel is none of these things. It's a brilliant reactive, single-user, file-based, desktop tool being asked to do the job of a live operational system.

If you're currently managing expiry dates in Excel and it feels like the spreadsheet is slowly falling apart under the weight of your inventory, you're not doing anything wrong. You've simply reached the boundary of what the tool can do. Here are the seven specific ways that boundary manifests.

1. No automatic alerts — the spreadsheet waits for you to look at it

This is the most critical failure, and it's worth understanding why it matters so much.

Expiry management is fundamentally about timing. A product that expires in 7 days has a 7-day decision window. A product that expires tomorrow has a few hours. The value of knowing about an approaching expiry date is directly proportional to how early you know — early knowledge lets you discount the product, push it to a high-traffic location, return it to the supplier, or adjust your next order. Late knowledge lets you throw it in the bin.

Excel does not alert you to anything. It sits on your desktop (or in your Google Drive) and waits. It does not send you a notification at 6 AM saying "14 items expire in the next 3 days, total value ₹8,400." It does not push an alert to your phone when a supplier return window is closing. It does not interrupt your morning with the information you need before the store opens.

You have to open the spreadsheet, navigate to the right tab, look at the right column, mentally filter for what matters, and then decide what to do. This requires you to remember to check, have time to check, and correctly interpret what you see. On a busy Tuesday morning with three customers waiting, a delivery arriving, and a staff member calling in sick, "checking the expiry spreadsheet" drops to the bottom of the priority list. And the 14 items that needed attention expire quietly, costing you money you didn't even know you were losing.

A dedicated inventory system sends proactive alerts. It tells you what needs attention without you asking. This single capability — the system reaching out to you instead of you reaching into the system — is arguably worth the entire cost of replacing the spreadsheet.

2. No FEFO enforcement at the point of sale

First Expiry, First Out is the foundational principle of perishable inventory management. Sell the oldest batch first. It sounds simple, and in a spreadsheet, you can certainly sort by expiry date and see which batch should sell next.

But the spreadsheet is in the back office. The billing counter is in the front. When a customer places 5 units of yogurt on the counter and the billing clerk scans them, the billing system records a sale. It does not check whether those 5 units came from the batch expiring on February 24th (which they should) or the batch expiring on March 5th (which is what the clerk grabbed because it was in front). The sale gets recorded identically either way. The spreadsheet, even if it's perfectly maintained, has no mechanism to enforce or even suggest FEFO at the moment of sale.

What happens in practice: the newer stock — which is usually in front because deliveries get placed in accessible spots — sells first. The older stock sits behind it and expires. This is LIFO by default, which is the exact opposite of what you need. The waste this causes is persistent and invisible, because the billing system shows healthy sales and the spreadsheet shows stock that's theoretically in order. The problem only becomes visible when someone physically finds the expired batch in the back of the shelf.

A system integrated with your point of sale can flag FEFO violations in real time: "You're billing batch 4055 (expires March 5), but batch 4021 (expires Feb 24) is still in stock. Switch to 4021?" This feedback loop, happening at the moment of sale, prevents the waste before it occurs. No spreadsheet can do this.

3. No batch-level date handling at scale

At 20 SKUs, tracking batches in Excel is manageable. You create a row for each batch, enter the expiry date, update quantities as you sell. It's tedious but workable.

At 100 SKUs, each with 2-5 active batches, you're maintaining 200-500 rows of batch data. Every sale, every delivery, every return requires finding the right row, updating the right cell, and ensuring the formulas still reference the right ranges. At this scale, the spreadsheet requires 30-60 minutes of daily maintenance just to keep it current.

At 300+ SKUs — common for supermarkets and pharmacies — the spreadsheet becomes a full-time job for one person. And that person becomes a single point of failure. When they're sick, on leave, or busy with something else, the spreadsheet doesn't get updated. When it doesn't get updated for two days, it takes twice as long to bring current. The maintenance burden grows faster than the inventory it tracks.

The deeper problem is that Excel treats each batch as an independent row of data with no relationship to other rows. A proper inventory system understands that batches belong to SKUs, SKUs belong to categories, categories have different shelf life characteristics, and all of this connects to suppliers, purchase orders, and return policies. This relational structure makes operations like "show me all dairy products expiring this week across all suppliers" trivial for a database and painful for a spreadsheet.

4. Manual updates create stale data — and stale data creates bad decisions

Here is the lifecycle of a data point in an Excel-based expiry tracking system:

• A delivery arrives at 10 AM
• The goods are received, counted, and placed in storage
• At some point — maybe immediately, maybe at end of day, maybe tomorrow — someone opens Excel and enters the batch number, quantity, and expiry date
• Between steps 2 and 3, the spreadsheet does not reflect reality

That gap — between the physical reality and the digital record — is where mistakes live. During that gap, someone might sell products without updating the sheet. Someone might check the spreadsheet and conclude that a product is not in stock when it's actually sitting in the storeroom, just not yet recorded. Someone might order more of a product that just arrived because the arrival hasn't been logged.

In a busy retail environment, "between delivery and data entry" is often 4-8 hours. For some operations, it's 24 hours. During that window, every decision based on the spreadsheet is based on incomplete information.

A system with barcode scanning or direct input at the point of receiving eliminates this gap. The delivery is logged as it's received — scan the barcode, enter the quantity, confirm the expiry date. The inventory is current from the moment of receipt. Decisions made 10 minutes later are based on accurate data, not yesterday's approximation.

This matters most for reorder decisions. If your spreadsheet says you have 30 units of a product but you actually have 80 (because yesterday's 50-unit delivery hasn't been entered), you might order another 50 units. Now you have 130 units of a product with a 10-day shelf life and daily sales of 8 units. Do the math: you'll expire 50 units. The reorder decision was perfectly logical based on the spreadsheet. It was perfectly wrong based on reality.

5. No multi-user concurrent editing (that preserves data integrity)

A retail operation has multiple people who need to interact with inventory data simultaneously: the store manager checking stock levels, the billing clerk recording sales, the warehouse person logging deliveries, the purchase manager creating orders. In Excel — even in cloud-based versions like Google Sheets — concurrent editing creates conflicts.

Google Sheets technically allows multiple simultaneous editors. In practice, with a large inventory spreadsheet containing thousands of rows and complex formulas, it's slow, prone to synchronization issues, and offers no workflow structure. Person A updates row 347 while Person B is filtering the sheet, and Person B's filter hides A's update. Person C sorts the sheet while Person D is entering data in what they think is the right row, and D's data ends up in the wrong row. Nobody intentionally makes errors. The tool creates the conditions for errors.

More fundamentally, a spreadsheet has no concept of roles or permissions at the data level. The billing clerk who should only be recording sales has the same access as the manager who controls purchase orders. There's no audit trail showing who changed what and when. When an expiry date is wrong — entered as March 2027 instead of March 2026, a single digit that costs you an entire year of false security — good luck figuring out who entered it, when, and whether any decisions were made based on the incorrect data.

A proper multi-user system provides role-based access, structured data entry workflows, and a complete audit trail. The billing clerk records sales. The warehouse person logs receipts. The manager sees everything and can trace any data point back to its origin. This isn't just about preventing fraud (though it helps) — it's about creating accountability in a process where small errors compound into significant waste.

6. No mobile access for shelf checks

Walk through any retail store with perishable products and you'll see the same scene: a staff member at the shelf, checking products, occasionally pulling something out, making mental notes about what needs attention. This shelf check — ideally performed daily — is one of the most important expiry management activities.

Now, how does the information from that shelf check get into the spreadsheet? The staff member either remembers what they found and enters it later (unreliable), writes it on paper and transcribes it later (slow and error-prone), or takes photos and someone interprets them later (cumbersome). In every scenario, there's a delay and a translation step between observation and record.

A mobile-accessible system changes this entirely. The staff member walks the aisle with their phone, scans or taps items that need attention, records observations in the moment, and the data is instantly in the system — available to the manager, triggering alerts if needed, updating the dashboard. The shelf check goes from a disconnected physical activity to an integrated part of the inventory management workflow.

This sounds like a convenience. It's actually a fundamental shift. When shelf checks are disconnected from the system, they happen inconsistently and their findings get lost. When shelf checks feed directly into the system, they become routine, reliable, and actionable. The shelf check is often the last opportunity to catch a product before it expires. Making that last opportunity count requires a tool that works in the aisle, not on the desktop.

7. Formulas break at scale — silently

This is the failure mode that most Excel users have experienced but few talk about openly, because it feels like a personal error rather than a tool limitation.

You build a formula. It works. You add rows. The formula still works. You add more rows. Still works. Someone inserts a row in the middle of a range. The formula now references the wrong cells. Or someone copies a formula and the relative references shift. Or a VLOOKUP references a range that no longer contains the value it's looking for because the source data changed structure. Or a conditional formatting rule that highlighted near-expiry items stops working because the date column got moved.

The insidious thing about spreadsheet formula errors is that they fail silently. The cell shows a number. The number looks reasonable. Nobody questions it. The formula that calculates "days until expiry" for row 234 is now calculating it based on the wrong date, and the product expires without anyone being alerted.

Research on spreadsheet errors consistently finds that a significant percentage of large spreadsheets contain formula errors. In a context where those errors translate directly into expired products, missed returns, and financial waste, "a significant percentage" is not an acceptable error rate.

A database-driven system doesn't have this problem. The logic that calculates days-to-expiry is written once, tested, and applied uniformly to every record. It doesn't shift when rows are inserted. It doesn't break when data is sorted. It produces the same correct result for the first record and the ten-thousandth record. This consistency — boring, invisible, reliable consistency — is what you need when tracking hundreds of expiry dates.

What to look for in an Excel replacement

If you've recognized your own experience in the seven failures above, here's what matters when evaluating alternatives:

Proactive alerts, not just reports. The system should notify you about approaching expiry dates before you ask. Alerts should be configurable by product category — 3 days for dairy, 7 days for fresh grocery, 30 days for packaged goods, 90 days for pharmaceuticals.

Batch-level tracking as a first-class feature. Not "you can add a note about the batch" but "the system thinks in batches." Every unit of every SKU should be linked to a specific batch with a specific expiry date. Partial quantities within batches should be trackable.

Point-of-sale integration. The system should influence what happens at the billing counter — flagging FEFO violations, preventing sale of expired products, enabling targeted discounts on near-expiry items. If the expiry system and the billing system don't talk to each other, you've just moved the spreadsheet problem into a different tool.

Mobile access. If the system can't be used in the aisle during a shelf check, it's a back-office reporting tool, not an operational management tool. The people who catch expiry problems are on the shop floor, not at a desk.

Multi-user with roles. Different people need different access levels. The system should accommodate this without creating the data integrity risks of a shared spreadsheet.

Supplier return tracking. The system should know your suppliers' return policies and alert you when batches approach return windows. This is where significant money is recovered — if you know in time.

Honest pricing. Look for transparent pricing that matches your scale. A 5-SKU kirana store and a 500-SKU supermarket have different needs and different budgets. The tool should scale with you, not charge enterprise prices for small-store features.

The transition doesn't have to be dramatic

The most common objection to replacing an Excel-based system is the disruption cost. "We know our spreadsheet. It works well enough. Learning something new takes time we don't have."

This is a legitimate concern. The best approach is usually incremental: start by entering your current inventory with expiry dates into the new system. Run both systems in parallel for a month — the spreadsheet for familiarity, the new system for alerts and FEFO tracking. After a month, you'll have enough experience to know whether the new system is earning its keep. Most retailers who make this transition report that the alerts alone — being told what needs attention instead of having to discover it — justify the switch within the first few weeks.

The spreadsheet doesn't go away overnight. It phases out as the new system proves itself. And if you've been losing even a small percentage of revenue to expiry waste that a proactive system could prevent, the payback period is usually measured in weeks, not months.

ShelfLifePro was built specifically to solve the problems described in this article — proactive expiry alerts, batch-level tracking, FEFO enforcement, mobile shelf checks, and supplier return management. If you're ready to move beyond Excel for expiry tracking, it might be a good fit. If you're not sure, the trial period costs nothing and the worst case is you go back to your spreadsheet with better information about what you need.