← Portfolio — Kewin Madej

DinGO

Case Study by Kewin Madej

From a family problem to a commercial constraint-based scheduling application

DinGO is the first software project I built from the ground up. What started as a tool to help my mother create monthly work schedules gradually evolved into a commercial desktop application powered by Google OR-Tools CP-SAT and used by multiple store managers.

Building it completely changed the way I think about software engineering, problem solving and AI-assisted development.

Python
PySide6
Google OR-Tools
CP-SAT
Desktop Application
AI-assisted Development
DinGO desktop application

At a Glance

4 Months of development
~1h Average coding time per day
10-20 Employees scheduled
CP-SAT Optimization engine
< 60s Schedule generation time
v1.0 Deployed in production

Contents

The Problem

DinGO started with a real-world problem rather than a programming exercise. My mother became an assistant store manager at a Dino supermarket, where one of her monthly responsibilities was preparing work schedules for around fifteen employees. I initially assumed this could be solved with a better spreadsheet. The more I learned about the rules involved, the more I realized I wasn't dealing with a spreadsheet problem at all, but with a constraint optimization problem.

Business Constraints

  • At least one certified employee had to cover the meat department.
  • Only selected employees could open or close the store.
  • Every employee needed at least 11 hours of daily rest.
  • Weekly schedules had to respect the required 35-hour rest period.
  • Vacations and sick leaves had to be respected.
  • Employee preferences had to be considered whenever possible.

Why It Was Difficult

What surprised me most was how quickly the complexity grew. A single vacation, shift swap or sick leave could trigger a chain reaction that forced large parts of the schedule to be rebuilt manually.

At that point I understood that the real challenge wasn't creating a timetable. It was finding a solution that satisfied many interconnected business and legal constraints at the same time.

From Excel to DinGO

My first solution wasn't a desktop application at all. It was GoogleSheets spreadsheet that counted employees assigned to each shift and highlighted understaffed days. It immediately saved some manual work, but after using it for a while I realized I had only made schedule creation slightly faster—I hadn't actually solved the problem.

Excel Prototype

The spreadsheet could count employees and highlight staffing shortages, but every scheduling decision still had to be made manually. All legal requirements, employee qualifications and personal requests remained the manager's responsibility.

First Google Sheets prototype

The Turning Point

At first I kept thinking about how to improve the spreadsheet. Then I realized I was asking the wrong question. The problem wasn't how to calculate the schedule faster—it was how to generate one that already respected all the rules.

That realization completely changed the direction of the project. Instead of improving Excel further, I decided to start over and build a desktop application from scratch.

Looking back, this was the moment when DinGO stopped being an Excel helper and became a software engineering project.

Building DinGO

When I started DinGO, I had only basic Python knowledge from university and no experience building applications of this scale. My first questions weren't about optimization algorithms or software architecture—they were about setting up Python, organizing the project and whether someone with my experience could realistically build something like this.

I worked full-time outside the IT industry, so most development happened during the evenings. Throughout the day I often thought about new features, UI improvements or ways to simplify individual constraints, then discussed those ideas with ChatGPT whenever I had a free moment. By the time I got home, I usually had a clear plan for what I wanted to build that evening.

Learning by Building

I never treated DinGO as a tutorial project. Every new feature existed because it solved a real problem my mother encountered while creating schedules. That made the learning process feel practical from the very beginning.

Instead of following a roadmap, I simply kept asking, "What's the next biggest problem?" Solving those problems one by one gradually taught me Python, desktop application development and software architecture.

The First Big Challenge

I underestimated how difficult scheduling would become. At first, heuristics felt like the obvious solution, but every new business rule broke something that had already worked. The more features I added, the more fragile the generator became.

After several iterations I realized I wasn't solving a programming problem anymore—I was solving a constraint optimization problem. That discovery eventually led me to Google OR-Tools and CP-SAT, which became the foundation of DinGO's scheduling engine.

AI-Assisted Development

DinGO wasn't only my first large software project — it was also where I learned how to work effectively with AI. My workflow changed significantly over the course of development as both the project and my understanding of software engineering grew.

How I Started

In the beginning my workflow was simple: describe the problem, copy the code, run the application, fix the errors and repeat. It worked surprisingly well for small features, but became increasingly difficult as the project grew.

At that stage I often understood what the code was supposed to achieve better than how it actually worked.

How It Evolved

Over time I shifted from asking AI to generate code towards using it as a learning and engineering tool. Instead of simply accepting solutions, I focused on understanding design decisions, testing every change and gradually taking ownership of the codebase.

That change had a much bigger impact on the project than any specific AI model.

Learning with ChatGPT

ChatGPT became my primary learning tool throughout the project. I didn't use it to replace learning—I used it because I wanted to learn faster. Almost every new concept I encountered, from Python fundamentals to constraint programming, started with a conversation before it became working code.

Early Workflow

  • Describe the problem.
  • Work on a single class.
  • Apply one change.
  • Test immediately.
  • Fix issues before moving on.

A Turning Point

As DinGO became larger, I realized that copying code without understanding it wasn't sustainable. I gradually shifted my focus from asking AI what to write to asking why a particular solution worked.

That change helped me understand Python, software architecture and constraint programming instead of simply assembling pieces of code.

Experimenting with Coding Agents

As the codebase grew, I started experimenting with more advanced AI development tools, including Codex and Google Antigravity. My expectation was that agentic, multi-file editing would make development significantly faster.

What Worked Well

  • Large-scale refactoring.
  • Splitting large classes into smaller modules.
  • UI improvements.
  • Keeping changes consistent across multiple files.

What Didn't

The scheduling engine required a different workflow. Multi-file changes made it difficult to understand exactly which modification affected the solver's behaviour. For constraint programming, I found that smaller, isolated iterations were much easier to verify.

One Constraint, One Test

The scheduling engine eventually became too important to modify through large, automated changes. Every new rule could influence several existing constraints, making it difficult to understand why the solver produced a particular schedule.

The Workflow

  • Identify one specific scheduling problem.
  • Modify only the responsible constraint.
  • Generate a new schedule.
  • Verify the solver's behaviour.
  • Only then continue with the next change.

What I Learned

This approach was slower than letting AI modify multiple parts of the project at once, but it gave me confidence that I understood every significant change inside the scheduling engine.

Looking back, this disciplined workflow became one of the biggest reasons why DinGO remained maintainable as the project continued to grow.

Architecture

As the project grew, keeping all logic in a single file quickly became unmanageable. I gradually split the application into smaller modules with clearly defined responsibilities, making it easier to extend and maintain.

DinGO layered software architecture

Main Components

  • Domain Model
  • ScheduleController
  • AutoScheduleGenerator
  • Constraint Modules
  • PySide6 User Interface
  • Persistence Layer
  • Export Module

Design Goal

Each layer was responsible for a specific part of the application. The scheduling engine focused exclusively on generating valid schedules, while the controller coordinated communication between the user interface, the data model and the generator.

Separating these responsibilities made the project significantly easier to evolve as new features were added.

Scheduling Engine

The core of DinGO is a scheduling engine built on Google OR-Tools CP-SAT. Instead of relying on heuristics, the application models the scheduling problem as a constraint optimization task, allowing the solver to search for schedules that satisfy mandatory rules while optimizing preferred ones.

Hard Constraints

  • One shift per employee per day.
  • Minimum staffing requirements.
  • Meat department coverage.
  • Qualified openers and closers.
  • 11-hour daily rest.
  • Employee availability.
  • Locked manual assignments.

Soft Constraints

  • Balanced workload.
  • Balanced morning and afternoon shifts.
  • Preferred employee requests.
  • Monthly target hours.
  • Reducing unnecessary penalties.
CP-SAT scheduling flow

Generation Flow

Although generating a schedule appears to be a single action from the user's perspective, the application performs several independent steps before a valid monthly schedule is displayed.

Schedule generation workflow

Generation Process

  1. User starts schedule generation.
  2. The current schedule is saved for Undo.
  3. A new CP-SAT model is created.
  4. Decision variables are generated.
  5. Hard constraints are applied.
  6. Soft constraints are added to the objective.
  7. The solver searches for the best solution.
  8. The result is mapped back into the schedule.
  9. The interface refreshes automatically.

Performance

Generation is performed in a background thread, allowing the interface to remain responsive while the optimization is running.

Once the solver finishes, the generated shifts are translated into the application's data model and immediately displayed to the user.

Manual Overrides

Automatically generating a schedule wasn't enough. Store managers still needed the flexibility to make manual adjustments without losing them during the next generation. DinGO was designed to support collaboration between the user and the scheduling engine rather than replacing human decisions.

Locked Assignments

Any manually edited shift could be locked. During the next generation, the solver treated those assignments as fixed and built the rest of the schedule around them instead of overwriting the manager's decisions.

  • Manual shifts remain unchanged.
  • Leave and sick days are preserved.
  • Only unlocked cells are regenerated.

Designed for Real Work

This feature reflected how schedules are actually created in practice. Managers often promise specific shifts before the schedule is finished, receive last-minute requests or need to react to unexpected absences.

Instead of forcing users to regenerate everything from scratch, DinGO allows automation and manual planning to work together.

Manual schedule editing
Locked schedule assignments

Commercial Validation

DinGO was never intended to become a commercial product. It started as a personal project built to help my mother, but after seeing how much time it saved, she told me that many other store managers faced exactly the same challenge.

The First Validation

To test whether the problem existed beyond a single store, I created a simple landing page, recorded a short YouTube demonstration and shared the project in a Facebook group for Dino store managers.

  • Approximately 1,000 views within the first few hours.
  • Private messages from managers interested in purchasing the software.
  • The first paying customers shortly afterwards.

Real Users

The most important validation wasn't the initial interest — it was that people actually started using the application in their daily work.

My mother still uses DinGO to prepare monthly schedules, and the project continues to evolve based on practical experience and user feedback.

Facebook announcement
YouTube presentation
YouTube analytics

Reflection

Looking back, DinGO changed much more than my programming skills. When I started, I thought software engineering was mostly about writing code. I finished the project realizing that understanding the problem is usually much harder than implementing the solution.

What Changed

I began this project asking ChatGPT how to build a desktop application. Four months later I found myself thinking about architecture, trade-offs, optimization problems and maintainability instead of individual lines of code.

The biggest shift wasn't learning Python. It was learning how to approach unfamiliar problems, break them into smaller pieces and keep moving forward even when I didn't yet know the solution.

My Biggest Lesson

AI made me more productive, but only after I stopped treating it as something that writes code for me. The more I focused on understanding the reasoning behind each solution, the faster I learned and the more confident I became making technical decisions on my own.

DinGO started as an attempt to save my mother a few hours each month. It ended up changing the way i think about AI-development.

What's Next

Although DinGO already solves the original problem, I still see many opportunities to improve both the product and its architecture. Working on this project also changed the direction of my learning and the technologies I want to explore next.

Future Improvements

  • Smarter schedule repair without full regeneration.
  • Additional optimization objectives.
  • Improved reporting and analytics.
  • Cloud synchronization.
  • Automatic updates.
  • More configurable scheduling policies.

Looking Forward

DinGO gave me a strong foundation in Python, desktop application development and constraint programming. My next goal is to apply the same problem-solving mindset while learning modern mobile development with React Native and building AI-assisted applications.

I see DinGO as the beginning of my software engineering journey rather than its final destination.

Resources

If you'd like to explore the project further, here are the main resources related to DinGO. The repository, portfolio and supporting materials provide additional technical details beyond this case study.

Project Links

Project Summary

  • Desktop application built with Python and PySide6.
  • Scheduling engine powered by Google OR-Tools CP-SAT.
  • Designed for real store managers and validated by real users.
  • Developed using an AI-assisted workflow focused on understanding and iterative improvement.
  • Continues to evolve as both a product and a learning project.