Client Background
SEM Restaurant needed a controlled workflow for turning operational files into structured outputs that teams could review and reuse. The operating model depended on consistent field transformations, dependable categorization logic tied to NIF rules, and an output destination aligned with existing reporting habits in Google Sheets. The engagement focused on scoping an approach that keeps categorization logic under direct control while improving run visibility for operators.
NextGen Coding Company partnered with SEM Restaurant to plan an External Python Solution built around a desktop UI paired with backend processing hosted on AWS. Planning emphasized flexibility for future enhancements, lookup-table governance for categorization rules, and a processing experience that offers clear execution status and meaningful error awareness.
The Problem
SEM Restaurant required a single workflow that supports field transformations, NIF-based categorization, and publication of results into Google Sheets. Several constraints shaped the scope:
Field transformations required a documented review so outputs remain consistent across files and refactor work.
Categorization logic needed a NIF-based approach using file-based lookup tables, allowing updates without model retraining or API changes.
Operators needed direct control over file selection, execution, and status or error monitoring inside a desktop UI.
Refactoring introduced meaningful risk of missed features, requiring deliberate validation through internal checks and integration testing cycles.
Hosting required an AWS infrastructure plan plus an operational cost line item.
Planning also reflected a preference to avoid added Nanonets costs while preserving full control over NIF-based categorization logic and improving visibility into processing outcomes.
Our Solution
NextGen proposed a modular delivery plan for a Python application spanning frontend and backend, using a desktop UI for operator control and AWS hosting for backend execution. The plan organized scope into requirements understanding, application scaffolding, UI screens, business logic integration, NIF-based categorization via file-based lookup, Google Sheets integration, AWS infrastructure hosting, internal testing, documentation, and integration testing aligned with a full refactor.
Two UI framework options remained under evaluation: PyQt and Tkinter. The desktop UI approach supported direct operator control over file selection and execution while improving transparency through visible status and error monitoring. Planning priorities aligned around several non-negotiables:
No added Nanonets costs
Full control over NIF-based categorization logic
Lookup tables updated without model retraining or API changes
UI-driven file selection, execution, and status or error monitoring
A stronger, extensible foundation for future enhancements
Requirements and Transformation Governance
Work began with a structured review of each field transformation. Field transformation ambiguity often becomes the source of downstream defects, especially during refactor work. A transformation-by-transformation review established expected outcomes and defined how validation would occur during testing cycles.
Key outputs from the transformation review included:
Agreed field transformation rules for processing runs
Shared expectations for how LLM actions for fields participate in the workflow
A reference baseline used during internal testing and integration testing
Application Scaffolding Across Frontend and Backend
NextGen planned Python application scaffolding for both frontend and backend components. The scope included LLM actions for fields, enabling a structured pathway for field handling as part of the processing pipeline. Scaffolding also established clean boundaries between UI interaction and backend execution, improving maintainability and supporting future enhancements without repeated rewrites.
Core scaffolding goals included:
A predictable execution pipeline from file selection through output generation
Clear separation between UI events and processing stages
A defined insertion point for LLM actions tied to field transformations
A structure that supports staged testing beyond end-to-end runs
Desktop UI Workflow
A desktop UI formed the operational control layer, supporting direct file selection, execution, and run visibility. The plan included a login screen and an upload screen as core workflow steps.
Login Screen The login screen served as the entry point to the application, supporting a consistent operator pathway into upload and execution. A predictable entry step improves repeatability and reduces accidental runs.
Upload Screen The upload screen served as the primary operator interface for selecting files and initiating runs. The design intent centered on direct file selection and clearer processing visibility, including status reporting and error awareness during execution.
UI framework options under evaluation included PyQt and Tkinter, with selection guided by usability for operators, extensibility, and compatibility with status or error monitoring needs.
Business Logic Integration
Business logic integration connected the UI-driven workflow to the processing pipeline responsible for transformations, categorization, and output formatting. Integration work coordinated field transformation rules, LLM actions for fields, NIF-based categorization logic, and the publishing pathway into Google Sheets.
Primary integration goals included:
Deterministic field transformations aligned to the requirements review
Coordinated LLM actions for fields within the processing stages
Consistent output formatting suitable for publication to Google Sheets
Error awareness surfaced through UI status reporting rather than hidden execution failures
NIF-Based Categorization Using File-Based Lookup
Categorization relied on NIF-based logic implemented via a file-based lookup. File-based lookup tables preserve full control over categorization behavior and allow updates without model retraining or API changes. That approach supports fast iteration when categorization needs evolve and reduces dependency friction tied to vendor platforms.
Key properties of the lookup-driven approach included:
Transparent categorization rules governed through lookup table updates
Flexibility to extend or adjust categories without retraining models
Consistent categorization behavior across processing runs
Google Sheets Integration
Google Sheets integration supported a familiar destination for structured outputs. Publishing results directly into a sheet reduces manual steps and supports review and downstream usage in a tool already embedded in daily workflows.
Integration goals included:
A repeatable publishing pathway from processed outputs into Google Sheets
Structured output formatting aligned with operational review needs
Reduced friction between processing runs and reporting workflows
AWS Infrastructure Hosting
AWS hosting supported backend execution needs and provided a standardized environment for processing. The scope included an AWS infrastructure hosting plan plus an operational cost line item.
Hosting goals included:
A stable environment for repeated processing runs
Alignment with refactor work and validation cycles
Clear ownership expectations for ongoing operations
Testing and Documentation
Validation received dedicated planning focus due to the full refactor requirement. The plan included internal testing, documentation, and integration testing to reduce feature drift risk and preserve expected processing behavior.
Internal Testing Internal testing targeted transformation correctness, lookup-driven categorization behavior, and readiness for publishing into Google Sheets. Internal checks reduce noise during later integration cycles and improve confidence in core logic.
Integration Testing Integration testing focused on end-to-end runs that exercise the full workflow: UI-driven file selection, execution, transformation logic, categorization via lookup tables, and publishing into Google Sheets. Refactor work increases the risk of missed features, making integration testing a primary mechanism for verifying feature parity.
Documentation Documentation supported operational readiness and maintainability, including guidance for operators on login, upload, execution, and error-state handling, plus guidance for lookup-table updates tied to NIF-based categorization.
Performance Considerations
Planning incorporated performance considerations aligned with Core Web Vitals principles for responsive UI behavior and user-perceived speed, with emphasis on stable execution, predictable status reporting, and efficient processing pathways. Mobile performance considerations remained tied to operational workflows that depend on Google Sheets as a destination, ensuring outputs remain accessible for review on mobile devices.
Caching and compression considerations remained part of broader performance planning in AWS-hosted execution and output handling, oriented toward reducing repeated processing work and minimizing payload overhead during data delivery into Google Sheets.
Alt Text References
Alt text reference: “Scoping table outlining a Python desktop UI, NIF lookup categorization, Google Sheets integration, AWS hosting, testing, and documentation for SEM Restaurant.”
Alt text reference: “Workflow diagram showing login, file upload, LLM field actions, NIF-based lookup categorization, and Google Sheets publishing for SEM Restaurant.”
Results
SEM Restaurant received a structured delivery plan for an External Python Solution with defined modules covering requirements understanding, application scaffolding, UI workflow design, business logic integration, NIF-based categorization via file-based lookup, Google Sheets integration, AWS hosting, internal testing, documentation, and integration testing aligned with a full refactor.
The planned architecture preserved control over categorization logic, supported lookup-table updates without model retraining or API changes, and aligned UI design around operator control of file selection, execution, and run visibility. The plan also reflected a clear preference to avoid added Nanonets costs while improving transparency for processing errors through UI-driven monitoring.
Why It Matters
A lookup-driven NIF categorization approach improves operational agility because category updates can occur through controlled file updates rather than model retraining cycles. A desktop UI approach improves day-to-day execution quality by giving operators direct control over runs and clearer visibility into status and error conditions. Google Sheets publishing supports faster review cycles and reduces manual handling steps, improving trust in outputs and decreasing operational friction.
AWS hosting supports a standardized execution environment that aligns with refactor validation needs and sets a foundation for future enhancements. The overall scope supports extensibility while maintaining control over key logic, reducing dependency risk tied to opaque third-party platforms.
