Overview

As an Applications Engineer at Sealed Air, a core responsibility involves conducting Factory Acceptance Tests (FATs) on large industrial packaging machines before they ship to customers. These machines have dozens of configuration points spanning software-defined recipe parameters, mechanical adjustments, and product-dependent settings, all of which need to be captured accurately and retained for the lifetime of the machine. Recognizing a persistent gap in how this data was managed, I took the initiative to design and build a standardized internal tool that replaced an ad-hoc, paper-based process with a structured digital workflow.

The Challenge

For years, FAT configuration data lived on scrap paper or in individual engineers' personal notes, creating a recurring organizational problem:

• Institutional knowledge was frequently lost when a machine had a field issue months or years after commissioning

• Project handoffs between engineers often meant configuration history was incomplete or inaccessible

• No standardized format existed for capturing mechanical and software properties across the 10+ machine types in Sealed Air's product lineup

• Engineers lacked in-context guidance during setup, increasing reliance on tribal knowledge and the risk of entry errors

Because the tool needed to be adopted and maintained by engineers rather than a dedicated software team, any solution also had to be simple, extensible, and easy to debug - not just functional.

My Role

I owned this project end-to-end, from problem definition through deployment:

• Authored a Product Requirements Document (PRD) defining the tool's scope, including customer project data (name, date, product types, line configuration) and structured, human-readable output

• Selected the technical approach: a WinForms (C#) backend with .NET-based UI framework, JSON machine configuration files, and formatted excel sheet outputs prioritizing fast iteration and low operational overhead

• Used Microsoft Copilot and Sealed Air's own GPT wrapper (enterprise-provided) as a development aid to scaffold the application, despite not having previously built a full web application independently

• Designed the data model to support 10+ standardized machine types, letting engineers define a customer project and build a multi-machine line from modular components

• Iteratively tested the tool across real customer commissioning scenarios before rolling it out for broader internal use

Building the Tool

The application walks engineers through data collection field-by-field for each machine in a line, with embedded reference diagrams and HMI screen visuals tied to the specific property being recorded to reduce lookup time and entry errors. It also incorporates a rules-based troubleshooting layer: when entered values fall outside historically validated ranges, the tool flags the discrepancy and surfaces relevant guidance, turning routine data entry into a source of institutional knowledge capture.

Key elements the tool centralized include:

• Machine-specific mechanical and software setpoints

• Customer project records tied to a defined line configuration

• Reference diagrams and HMI visuals linked to specific data fields

• Historical setpoint ranges used to flag out-of-range entries

Results & Impact

The tool delivered a reliable, standardized workflow for FAT data collection that replaced fragmented paper and notes-based processes across the team. Key outcomes included:

• A single source of truth for machine commissioning data that persists beyond any one engineer's involvement

• Organized, exportable tables replacing scattered notes and scrap paper

• Reduced entry errors and lookup time through embedded reference visuals

• Built-in troubleshooting guidance driven by historical setpoint data

• An extensible, JSON-backed architecture that made it straightforward to add new machine types as the product lineup grew

The project reinforced my ability to identify a systems-level operational gap, translate it into a formal product requirement, and independently deliver a working tool, while working within the constraints of a team without dedicated software development resources.