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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.