CafeNet Manager
A C++ / Qt desktop operations system for cafes and internet cafes.
CafeNet Manager is a desktop operations system built with C++17, Qt 6, SQLite, and CMake. It combines seat maps, timed sessions, ordering carts, kitchen display, checkout, customer records, and revenue dashboards into one local management interface.
Verified Demo Recording 1
Copied by the portfolio quality pass from existing project demo media.
Media overview
Browse the project screenshots and recorded walkthroughs.
Project links and demo readiness
live
Live Demo
Open the verified live demo when available, or use the internal run guide for manual demo preparation.
github
View GitHub
Open the public repository when available, or review the source-access status captured by this case study.
video
Demo Recording
Open the demo recording when available, or use this section as the recording checklist for the project.
documentation
README
Open the project README when available, or use this case study as the documentation baseline.
Project overview
CafeNet Manager is my representative C++/Qt desktop project for operations workflow modeling. It is not a single-feature exercise. It connects seats, timed sessions, orders, kitchen workflow, checkout, and customer management into one desktop system. The project forced me to model real operational state. A seat has status, capacity, amenities, and an active session. An order has cart items, preparation state, payment method, and checkout totals. Customer records can connect to history and notes. This is a different type of complexity from a visual portfolio site, and it required a more disciplined approach to state and data flow. The implementation uses C++17, Qt 6 Widgets, SQLite, and CMake. The architecture separates Presentation, Business Logic, Data Access, and Database layers. Repositories such as SeatRepository, OrderRepository, and MenuRepository isolate persistence from UI code, while widgets such as MainWindow, SeatMapView, CartWidget, KitchenBoardWidget, DashboardWidget, and CheckoutDialog handle the interface. In the portfolio, this project shows that my work is not limited to Web UI or metadata systems. I can also build database-backed desktop software, structure operational workflows, and reason about state-heavy business interfaces.
My role
Independent Developer / C++ Desktop Application Developer / Workflow System Designer
Problem
Small cafes and internet cafes often manage seats, timed sessions, orders, kitchen status, checkout, and customer records across disconnected tools or manual workflows, which makes operational state hard to keep consistent.
Solution
I built a multi-tab Qt Widgets desktop interface backed by a SQLite repository layer and service layer. Seat state, timed billing, orders, carts, kitchen boards, and checkout workflows are handled inside one local system.
Current outcome
The project is a complete C++/Qt desktop case study that demonstrates complex state UI, business workflow modeling, local persistence, and repository-based architecture.
Highlights
- Implements an interactive seat map concept with seat status, capacity, amenities, and management workflows.
- Supports both cafe minimum-charge sessions and internet cafe timed sessions with live status updates.
- Connects cart, order status, kitchen display, checkout, and receipt data flow.
- Uses a SQLite repository pattern to separate UI behavior from data access and business services.
Engineering challenges
- Seat, session, order, and payment state are linked, so UI updates must reflect the current operational model.
- Qt Widgets requires clear component boundaries so MainWindow does not absorb every business rule.
- The workflow is more complex than a typical portfolio card, so repositories, services, and widgets need separate responsibilities.
Target users
- Portfolio reviewers and interviewers
- Technical readers who need a quick view of purpose, stack, and maturity
Technical highlights
- Detected technical signals: C++, Qt, SQLite, CMake, Qt Widgets
- README evidence exists and can support a fuller reviewed case study
- A public GitHub repository is linked for source traceability
Architecture
This case study is generated from the portfolio catalog pipeline using README, Git metadata, package/build configuration, and media signals. The final architecture narrative still needs source-level review. Current detected technology signals include: C++, Qt, SQLite, CMake, Qt Widgets.
Data flow
A public data-flow narrative is not fully reviewed yet. If the project includes data processing, AI pipelines, or backend APIs, the next pass should document input, processing, storage, and UI/output flow end to end.
Project structure
cafe-net-manager/ README.md # project documentation, when available source files # implementation reviewed by local audit package/build config # detected capability signals
Setup / Run guide
This project does not expose a verified runnable web command yet. Review the README/source tree and add exact install, run, test, and build commands before interview use. No verified build command was detected. Treat the current portfolio page as a case-study placeholder until build steps are reviewed.
Future improvements
- Complete the production-quality README, screenshots, and demo recording
- Add architecture diagrams, data-flow notes, and key technical decisions
- Verify build/test status and update the portfolio release report
Interview notes
- State the current maturity and demonstrable scope first
- Focus on verified stack, source structure, and completed behavior
- Do not claim unverified deployment, video, or test coverage as finished
Next steps
- Add fuller staff roles, shift management, and inventory workflows.
- Add more report export formats and revenue visualization.
- Improve tests and database migration handling.