TL;DR:

As an API Inspector responsible for refinery shutdowns, I noticed the over-reliance on Excel for managing inspection tasks, which led to version control issues, scalability problems, and human error. While Excel is useful, it’s not built for complex projects like refinery turnarounds. Developing complex spreadsheets is akin to software development but without the necessary safeguards.

To solve these challenges, my colleagues and I developed SHIELD, a free app designed for inspectors to manage tasks more effectively. Built with a .NET backend and SolidJS frontend, SHIELD offers offline-first, secure, and collaborative functionality to address the limitations of Excel and other project management tools.

Background

In my role as an API Inspector, one of my key responsibilities is planning and coordinating shutdowns at refineries. This involves meticulous scheduling, ensuring safety, and overseeing the inspection and maintenance of critical equipment. These activities are essential to maintaining operational efficiency and preventing costly breakdowns.

A few years ago, my colleagues and I began to notice a recurring issue across multiple sites: the widespread use of Excel for managing and tracking inspection activities during turnarounds (TAs). While Excel is undoubtedly a flexible and accessible tool, we realized it was being used as a catch-all solution for tasks it wasn’t necessarily designed for. This over-reliance was creating problems, and the more we saw, the more frustrated we became with the status quo.

Excel has a reputation as a quick, low-cost solution, and in many cases, it's true—it can streamline processes, provide visibility, and help organize data. However, the assumption that it always saves time and money is misleading. Excel has significant drawbacks, especially when used for complex projects like refinery turnarounds that involve large amounts of data, real-time updates, and coordination across multiple teams.

One of the biggest issues we encountered was the lack of version control. With multiple team members making changes to the same spreadsheet, it became almost impossible to track who updated what and when. This often resulted in conflicting information, lost data, and errors that were difficult to trace back. In an environment where safety and precision are critical, these types of mistakes can have serious consequences.

Another limitation is scalability. As the scope of a project grows, so does the complexity of the Excel sheets. With hundreds or even thousands of rows of data, spreadsheets become cumbersome and difficult to navigate. Performance issues can also arise, with slow load times and an increased risk of crashes—particularly when dealing with large files or multiple users trying to access the same document simultaneously.

Perhaps the most concerning risk is human error. Excel lacks the robust validation and automation features that more specialized software offers. This means that a simple typo or miscalculation can go unnoticed until it causes a problem. There are numerous case studies where businesses have suffered significant financial losses or operational disruptions due to errors in spreadsheets, ranging from incorrect formulas to accidental deletions.

These issues are well-documented, and many organizations have started moving away from using Excel as their primary project management tool. There are now specialized platforms designed specifically for managing large-scale projects, offering features like real-time collaboration, data validation, audit trails, and automated reporting. These tools not only reduce the risk of errors but also provide a clearer and more comprehensive view of project progress, enabling better decision-making.

Despite its strengths, Excel simply wasn't built to handle the intricacies of complex projects like refinery turnarounds. As we’ve seen firsthand, its limitations can lead to inefficiencies, errors, and even safety risks. It’s important for businesses to recognize these shortcomings and explore alternatives that offer more robust, scalable, and secure solutions. While Excel may still have a place in certain tasks, it's critical not to over-rely on it for mission-critical operations.

Developers?

Here’s the thing: in my opinion, if you’re making a spreadsheet, you’re essentially writing software.

Think about it—when you create a spreadsheet, you're doing more than just entering numbers into cells. You're defining the logic behind how data is structured, manipulated, and displayed. Whether it's a simple formula to calculate totals or a complex system of interconnected sheets tracking project timelines, equipment statuses, and inspection schedules, you're engaging in a process that mirrors software development.

Like developers, you're defining inputs (data), writing logic (formulas and functions), and designing outputs (charts, tables, and reports). You're determining how the data interacts and flows through the system. In fact, a lot of what happens in software development—managing dependencies, ensuring data accuracy, designing user interfaces—also happens when you're building a robust spreadsheet.

But there’s a catch. While spreadsheets might seem easier to work with, they lack the rigor and structure of formal software development tools. Spreadsheets aren’t version-controlled by default, making it hard to track changes. They don't come with automated tests to check for errors, and they don't scale well when your project grows. All of these things are built into software development practices for a reason—they help avoid costly mistakes, improve reliability, and make systems easier to maintain.

In a way, many people are developers without realizing it. They may not write code in traditional programming languages, but when they rely on Excel or other spreadsheet tools to manage critical processes, they’re engaging in a form of development. The difference is that they're doing it without the safety nets and best practices that professional developers rely on to ensure their systems are reliable, scalable, and maintainable.

This is why I believe that if you're creating complex spreadsheets, you should approach it with the same mindset as software development. Understand that you're not just building a static file, you're creating a system that others will use, interact with, and possibly depend on. And like any other software, it needs to be designed with care, tested rigorously, and maintained over time. Otherwise, you’re opening the door to the same kinds of problems that poorly developed software can cause: data loss, errors, inefficiencies, and even security risks.

Ugly truth

The reality is, there are hundreds of project management tools available, each offering varying degrees of customization. Many of these tools are low-code or no-code solutions, which can be a big advantage.

Having the ability to choose a tool that helps you work more efficiently is fantastic. The wide range of options means you're likely to find something that suits your specific needs.

However, what I've noticed is that most of these platforms essentially provide you with a sandbox. While they offer tools to define your workflows, it's up to you to figure out how to structure everything.

The challenge is that most inspectors are only moderately comfortable with using computers, and they don’t want to spend weeks building a project tracker from scratch. And even if they do, there’s the issue of ongoing costs. After the turnaround is over, your company might not continue paying for the subscription. So, regardless of how well-designed the tool is, it’s likely to vanish once the budget runs out.

Where Do we go from here..?

So where does that leave us? I'm my case I ended up collaborating with a few colleagues to build something we could all use to solve these challenges.

We needed something that worked offline first, allowed for collaboration and was easy to use. It also needed to be secure and very reliable.

We built the first version about a year ago, using .NET backend and React for client side. It worked pretty well, unfortunately it only had limited offline support...

I spent the last three months, researching offline first tooling out there and playing with a variety of paid and self hosted option. I ended up using Replicache, it was a bit of a steep learning curve and they are a paid service. However I really liked that they were backend agnostic and allowed me to use my existing infrastructure very easily.

I also ended up changing front end out to solidjs. I really like React, and most of my experience in the front end is either react or blazor. However, I recently used solid for a hobby project and fell in love with it's reactivity and simplicity. The end result was an application that could run anywhere and was incredibly fast and small.

SHIELD

Introducing SHIELD, a free app we developed to help manage all your inspection tasks more effectively. We've seen the challenges firsthand, and SHIELD was created to address the limitations that come with relying on spreadsheets or overly complex project management tools.

SHIELD is designed with inspectors in mind. It simplifies the process of organizing and tracking inspections during turnarounds, without the need for complex setups or technical expertise. You can easily manage tasks, track progress, and ensure nothing falls through the cracks—all in one streamlined platform.

Best of all, SHIELD is free to use, making it an accessible solution for inspectors who need a reliable, no-cost tool. You can check it out and start using it today by visiting SHIELD.

With SHIELD, we’re giving you the tools you need to manage your inspection tasks more efficiently, without the headaches that come with spreadsheets or expensive subscriptions.

Summary

In refinery shutdowns, managing inspection tasks efficiently is critical, yet many teams still rely heavily on Excel for these complex projects. While Excel offers flexibility, it falls short when it comes to handling version control, scalability, and error prevention, leading to mistakes and inefficiencies that can jeopardize safety and operations.

Recognizing these limitations, we developed SHIELD—a free app designed specifically for inspectors. SHIELD addresses the common pitfalls of using spreadsheets in refinery turnarounds, offering a secure, offline-first, and collaborative solution. Built with a .NET backend and a fast, responsive SolidJS frontend, SHIELD simplifies inspection task management without requiring steep learning curves or expensive subscriptions.

In this post, we discuss the key issues inspectors face when relying on Excel, why SHIELD was built, and how it can improve the efficiency and reliability of inspection management.