Once Upon a Page
"Drag & Drop cards, complete puzzles, and explore the character's world of imagination!"
Role: Game Producer, Product Owner, Scrum Master
Development time: 4 months
Team Size: 7
Engine: Unity
Methodology: Scrum
Programming language: C#
Project management: Trello
Tools: Git & GitHub
Genre: 3D Puzzle, Card Game, Casual
Platform: PC
Year: 2026




About Once Upon a Page
Once Upon a Page is a cosy 3D puzzle game created by a seven-person team during the Game Project 3 course at Kajaani University of Applied Sciences. We developed it over approximately four months and released a playable demo on Steam.
The game takes place inside a child’s sketchbook. When the book opens, flat drawings unfold into small 3D worlds filled with hand-drawn textures, animated animals and playful interactions.
Players solve puzzles by dragging illustrated cards into the environment. A drawing of a dog becomes a 3D dog, a bag of food turns into seeds and every object reacts differently depending on where it is placed. Wrong answers do not cause failure. Instead, they lead to cute or funny reactions that encourage the player to experiment.
I worked as the Game Producer and Project Lead, covering both Product Owner and Scrum Master responsibilities. I also contributed directly to the game’s design and Unity development.
My Role
My main responsibility was keeping the project organised and helping the team finish a polished demo within the course deadline.
Our team included a designer, a lead artist, two additional artists, a lead programmer, another programmer and me as the producer. I worked closely with each department and held regular one-to-one meetings with the team leads, as well as short daily meetings with the full team.
We did not assign Product Owner and Scrum Master to separate people. As the producer, I covered both responsibilities. I maintained and prioritised the backlog, kept the overall direction clear, planned the work for each Sprint and helped the team deal with blockers.
I was also heavily involved in development. When something important was missing or falling behind, I often stepped in to prototype, implement or polish it myself.
My responsibilities included:
-
Helping define the concept, target audience, scope and product goals
-
Managing and prioritising the backlog in Trello
-
Planning Sprint goals and dividing larger milestones into smaller tasks
-
Organising daily Scrum meetings and regular one-to-one meetings
-
Tracking progress, dependencies, workloads, risks and deadlines
-
Supporting the team and helping resolve production blockers
-
Organising playtests, Sprint Reviews and team retrospectives
-
Maintaining the schedule, documentation, market research and simulated budget
-
Supporting the team with GitLab and version-control problems
-
Setting up the Steam page, achievements and demo release
​
A lot of my work happened between disciplines. I needed to understand what the programmers were waiting for, which assets the artists still needed to create and whether the planned puzzles were realistic to finish before the next milestone.
Project Goals
Our original goal was to create a calm puzzle game for children and casual players. We wanted the controls to be easy to understand and the experience to feel safe, creative and free from pressure.
The first concept included several sketchbook sections based on different parts of a child’s imagination, such as a farm, outer space and pirates. Each section would contain its own environment, puzzle ideas, cards and character interactions.
The main idea was that every 2D drawing should become something alive inside the 3D world. Correct placements would solve the puzzle, while incorrect choices would still lead to a unique reaction instead of simply showing an error.
We also wanted the visual style to remain consistent despite combining 2D illustrations, 3D models, cardboard environments and hand-drawn textures. The Art Bible focused on soft colours, clear silhouettes, simple shapes and readable objects that would appeal to children without becoming visually overwhelming.
Production Process
We used Scrum throughout the project.
We organised the day-to-day work into Sprints while using the course milestones, presentations, playtests and release deadline as our main delivery points.
At the beginning of each Sprint, I reviewed and prioritised the backlog in Trello, planned the upcoming work and helped the team agree on the most important goal for that Sprint. We held short daily Scrum meetings where everyone explained what they had completed, what they planned to work on next and whether anything was blocking them. I also held separate one-to-one meetings with the lead artist, lead programmer and other team members whenever a problem needed more time than the daily meeting allowed.
At the end of each Sprint, we reviewed the current version of the game, discussed what was working and adjusted the next Sprint. Playtests acted as larger Sprint Reviews, while team discussions and the final post-mortem helped us look at how we were working and what needed to change.
​
​
The development was divided into four main stages:
January - February — Concept and pre-production
We started by forming the team, brainstorming ideas and choosing the sketchbook puzzle concept.
During pre-production, we worked on the Game Design Document, Technical Design Document, Art Bible, puzzle concepts, market research, production schedule and budget.
We originally planned a much larger game with several themed sections. The farm would be followed by environments based on space, pirates and other parts of the child’s imagination.
The project initially began in Unreal Engine because it was the preferred engine of our lead programmer. The artists and designer began developing the visual style and puzzle concepts while the programming team worked on the first technical prototype.
Late February - March — Engine switch and first playable version
After approximately one month, we still did not have a working version of the core gameplay loop. This meant we had not yet been able to test whether the main idea of dragging 2D cards into a 3D sketchbook world actually worked.
Continuing in Unreal would have placed the entire project at risk, so we made the difficult decision to switch to Unity. The engine switch meant restarting most of the technical work, rebuilding the repository and adjusting the backlog and schedule. I created the first Unity prototype so we could finally test the central interaction and begin connecting the work from programming, art and design.
We prepared the first playable version for a playtest in March. The session showed that the idea had potential, but it also revealed usability problems and larger issues with the team’s communication and workflow.
After the playtest, I organised a longer team discussion. Everyone had the chance to explain what was going wrong, what they needed from the rest of the team and what we could realistically finish. During this retrospective, we agreed to reduce the scope from a larger multi-section game to a three-level farm demo. This gave the team a clear and achievable goal for the remaining Sprints.
April — Main production and second playtest
Once the scope was clearer, the team focused on completing the three farm levels.
The first level became a simple tutorial where the player places a dog card and watches the dog guide the sheep into the barn. The later levels introduced more cards, more possible placements and more incorrect reactions.
I created a no-text tutorial using animated arrows and cursor symbols. It guides the player through opening the book, dragging a card, placing it and removing an incorrectly placed object. Because the game was designed partly for young children, I wanted the tutorial to work without relying on written instructions. I also worked on the main menu, settings, scene transitions, weather effects, lighting, Steam achievements and smaller quality-of-life improvements.
The second playtest allowed us to review the full progression and decide which usability issues and bugs needed to be prioritised before release.
May — Final Sprint and Steam demo
The final Sprint focused on testing, bug fixing, presentation, documentation and Steam preparation.
I set up the Steam page and coordinated the required store graphics with the artists. I also checked that the project documentation was complete and supported team members with their final reports.
The demo was published on Steam at the beginning of May. We then completed post-release fixes, the final presentation, another playtest and a team post-mortem. The demo is currently available to download for free on Steam!

Challenges and Solutions
The biggest challenge was the engine switch. We had spent roughly one month working in Unreal before realising that the core loop was not progressing quickly enough. By that point, art and design had moved forward, but we still could not properly test the game. Switching to Unity cost us time, but continuing with an engine that was blocking development would have been a much larger risk. I reorganised the backlog, adjusted the upcoming Sprints and created the initial Unity prototype so we could get a playable version ready as quickly as possible.
Version control was another major problem. The engine switch required us to rebuild the repository, and we continued experiencing merge conflicts throughout development.
Team members sometimes worked in the same Unity scenes without communicating or forgot to pull the latest version before making changes. I explained the Git workflow, helped resolve conflicts and regularly reminded people to communicate before editing shared scenes.
This experience taught me that reminders alone are not always enough. A stronger solution would have been to introduce written version-control instructions, stricter ownership of shared scenes and earlier intervention when the same problems continued.
The departments also became out of sync at different points in the project. Early on, art and design were ahead while very little programming had been completed. Later, programming caught up, but there was not enough finished art and puzzle content ready for implementation.
I used the daily meetings, backlog and one-to-one discussions with the leads to understand what was blocking progress and move attention towards the work the team needed most.
As the delays continued, motivation dropped across the team. After the first playtest, I organised an honest retrospective where everyone could speak openly about the project.
Reducing the scope to a demo initially felt disappointing, but it gave the team a realistic target again. From that point, we were able to focus on the three farm levels, meet the deadline and release something complete.
Gameplay
The player opens a child’s sketchbook and solves small puzzles by dragging illustrated cards into the 3D world.
The main gameplay features include:
-
Drag-and-drop card puzzles
-
2D drawings that transform into animated 3D objects
-
Three farm-themed levels with increasing complexity
-
A visual no-text tutorial
-
Correct and incorrect placement reactions
-
Cards that can be removed and tried somewhere else
-
A no-failure design with no timers, scores, lives or game-over screens
-
Sketchbook pages that unfold into 3D environments
-
Page-turning transitions between levels
-
Hand-drawn textures and cardboard-inspired environments
-
Mouse and keyboard controls
-
Steam achievements
-
Audio, graphics and weather-effect settings
The first level introduces the mechanic with one dog card and one possible location. Placing the dog correctly causes it to guide the sheep into the barn. Later levels give the player more cards than they need. They must work out which objects belong in each location, but they are free to experiment. Placing the wrong card may cause a cat to fall asleep, a dog to bark at the chickens or another character to react in a funny way. Once all the correct cards have been placed, the 3D environment folds back into a drawing and the sketchbook turns to the next page.
Playtesting Feedback
We held three main playtesting sessions during the project: one in March, another in April and a final session in May.
The first playtest was especially important because it was our first chance to test the concept after switching engines. The session showed that players liked the idea, but the controls and first steps were not immediately obvious. Some players did not understand that they needed to click the sketchbook, drag a card into the scene or remove a card after placing it incorrectly.
Because the target audience included children, we did not want to solve this with long written instructions. I created a visual tutorial using arrows, cursor symbols and animated guidance that takes the player through the entire first level.
Later testing focused on the full progression, puzzle clarity, incorrect reactions, scene transitions and general polish. We added issues to the backlog and prioritised the most important fixes during the following Sprint Planning sessions.
Playtesting also affected the project at a much larger level. The discussion after the first session led directly to the engine-switch recovery plan, the scope cut and the decision to focus on one polished farm section.
Outcome
We completed and published a playable Once Upon a Page demo on Steam within the course deadline.
The demo contains one farm-themed section with three increasingly complex levels. It includes the drag-and-drop card system, correct and incorrect character reactions, a visual tutorial, page transitions, settings, achievements and a fully hand-crafted visual style.
Although the finished demo was smaller than our original idea, it captured the most important part of the concept: watching a child’s drawings come alive and experimenting with the different ways they can affect the world.
For me, the project became my most demanding producer experience so far. I led a seven-person team, handled Product Owner and Scrum Master responsibilities, coordinated department leads, maintained the backlog and schedule, created a budget, managed a major engine change, reduced the scope and still helped the team release the demo on time.
What I Learned
Once Upon a Page taught me more about production than any project where everything simply went according to plan.
Using Scrum gave us a structure for handling a project that changed constantly. The backlog, daily meetings and Sprint Reviews helped us keep moving even after the original plan stopped being realistic.
The engine switch taught me how important it is to test the riskiest part of a game as early as possible. We spent too much time planning levels and content before proving that the core interaction worked. In future projects, I would set a much earlier prototype deadline and treat missing it as a clear sign that the project needs attention.
I also learned that daily meetings are useful, but they do not solve communication problems by themselves. When the same issue keeps happening, a producer needs to change the workflow, clarify ownership or ask for support instead of repeating the same reminder.
The project also changed how I think about scope cuts. Reducing the game to a demo initially felt like a failure, but it was actually one of the most important decisions I made. A smaller complete game was much more valuable than several unfinished sections.
I also learned that stepping in and doing extra development work can help save a milestone, but it cannot replace solving the underlying production problem. A producer needs to support the team without quietly taking responsibility for every task that falls behind.
Most importantly, the project showed me that I can continue leading a team even when the original plan falls apart. We switched engines, rebuilt the game, reduced the scope and still released a demo that felt unique and true to the original idea.