Scaredy Cat
"A scaredy cat steps into the forest alone to find a rare flower for her friends — but some journeys are more than they seem."
Role: Game Producer & Developer
Development time: 3 months
Team Size: 6
Engine: Unity
Methodology: Agile
Programming language: C#
Project management: Trello
Tools: Git & GitHub
Genre: 3D Narrative Adventure, Puzzle Game
Platform: PC
Year: 2025




About Scaredy Cat
Scaredy Cat is a short emotional narrative adventure created by a six-person international team during the Summer Studies course at Kajaani University of Applied Sciences. We developed it in Unity over approximately three months and released it on Steam and itch.io.
The player takes the role of a young kitten who wants to prove that she is brave enough to cross the darkest part of the forest and find a rare flower on her own. What begins as a simple dare slowly turns into something more personal as she meets the inhabitants of the forest and has to face the truth about herself.
The game combines exploration, dialogue, quests, puzzles and short parkour sections. We wanted it to feel like an interactive storybook: colourful, playful and easy to approach, while still telling an emotional story underneath.
Our team consisted of four artists and two programmers. Five team members came from Singapore, while I joined the project from KAMK in Finland. We began development together in person in Kajaani before later moving to fully online collaboration.
My Role
I worked as the Game Producer and Lead Developer during this project.
As the producer, I helped the team define the concept and scope, organised the work and kept the different parts of development connected. As the lead developer, I worked closely with our second programmer and took responsibility for bringing the gameplay systems, artwork, animation, narrative and audio together in Unity.
Most of the communication between the artists and programmers went through me. I also kept track of what the game still needed, handled the Steam setup and continued improving the game after its release.
My responsibilities included:
-
Helping the team define the game concept, scope and main priorities
-
Planning milestones and organising tasks through Trello
-
Coordinating a six-person international multidisciplinary team
-
Helping the team move from in-person to fully online development
-
Keeping communication moving between the artists and programmers
-
Tracking assets and managing dependencies between gameplay, art, animation, narrative and UI
-
Integrating models, textures, animations, audio and UI into Unity
-
Programming gameplay systems in Unity with C#
-
Creating the dialogue system and implementing optional NPC dialogue
-
Managing version control through Git and GitHub
-
Testing the complete game and prioritising gameplay, visual and integration issues
-
Setting up the Steam page and coordinating the store submission, promotional materials, release and post-launch updates
Project Goals
We chose the Published Game track for the Summer Studies course, so our goal was not only to make a prototype. We wanted to finish and publicly release a complete game within approximately three months.
Our main goal was to create a short top-down 3D adventure with simple controls, varied locations and a visual style inspired by illustrated storybooks. The game needed to be approachable for players who did not normally play many games while still offering enough variety to keep the experience interesting.
We also wanted each area to feel different. Instead of repeating the same activity throughout the game, we included character quests, environmental puzzles, memory-based challenges and short parkour sections.
The project was very asset-heavy. The artists were creating characters, environments, animations, cutscenes, UI and promotional materials while the programmers developed the gameplay systems. Keeping the technical and creative work connected was therefore one of the most important parts of the project.
Production Process
We used an Agile and iterative approach throughout development. We organised tasks through Trello, created playable versions early and regularly adjusted our priorities as new assets, feedback and technical problems appeared.
Git and GitHub were used for version control. This allowed me and another programmer to work on different systems and regularly combine our changes in the same Unity project.
Because many features depended on work from several disciplines, I also tracked what was needed before something could be considered complete. A quest might require programming, dialogue, a character model, animation, an item, UI and audio before it was ready for the player.
The development was divided into five main stages:
Late May - Early June — Kick-off and planning
We began with orientation, brainstorming and design meetings. We agreed on the main story, gameplay direction and visual style, then divided the first responsibilities between the artists and programmers. We presented our plans early in the course, which gave us a clearer understanding of the amount of art, animation and technical work the project would require.
June — First prototypes and core systems
We focused on getting playable content into Unity as early as possible. My work during this stage included menus, player movement, audio, dialogue, cutscene systems, the labyrinth and the first level prototypes. The goal was to test the main game flow before all of the final assets were available. This helped us identify which ideas worked, which systems depended on each other and which parts of the original concept needed to be simplified.
July — Online development and content integration
After beginning the project together in Kajaani, we moved to fully online development. The artists continued working on characters, environments, animation, UI and cutscene materials, while the programmers developed gameplay and progression systems. Clear communication became especially important because we could no longer solve every problem by speaking to each other in the same room. I spent much of this stage integrating models, textures, animations, audio and UI, building scenes, setting up collisions and connecting the different parts of the game. I also kept track of missing assets and communicated with the artists when something needed to be adjusted before it could work properly in Unity.
Early August — Final integration and presentation
As the final presentation and course deadline approached, we focused on making the game playable from beginning to end. I tested the complete game flow, fixed scene and integration problems and checked that quests, dialogue, transitions, animations and saving worked together. We also continued improving the visuals, atmosphere and final presentation.
August — Steam setup and release
I was responsible for setting up and managing the Steam page. This included paying the publishing fee, writing the store description, selecting tags, completing the age-rating information and keeping track of the screenshots and promotional artwork that still needed to be delivered. Steam initially rejected some of our materials, so I had to understand what needed to change, communicate the new requirements to the artists and organise the updated submissions. The additional work delayed the original release plan, but we successfully released Scaredy Cat on Steam and itch.io.
Post-release development
My work did not end after publication. I continued reviewing player feedback, fixing visual and gameplay bugs and preparing updated builds. Some players found the parkour section frustrating and more difficult than the rest of the game, so I returned to it and made changes to improve the movement and make the section easier to complete.

Challenges and Solutions
One of the biggest challenges was keeping an asset-heavy project organised. Many parts of the game depended on each other, and a scene could not be finished until the required programming, models, textures, animations, dialogue, UI and audio were all ready. I kept track of these dependencies and regularly checked which missing elements were preventing a scene or feature from being completed.
Moving from in-person development to fully online work also changed how the team communicated. It became easier for information to be separated between disciplines or for people to be unsure about what was still needed. I helped keep the art and programming sides connected, followed the progress of missing materials and made sure technical requirements were communicated before they became major blockers.
Texture integration was another challenge. Some materials looked different in Unity than they did in the artists’ software. The foliage caused the most problems because its transparent areas rendered incorrectly. Daniel and I spent several days testing materials and settings until we found a solution that worked properly.
Creating the dialogue system was also a major technical challenge for me. I had never built one before, but the game needed a way to manage a large amount of dialogue without placing every conversation manually inside Unity scenes. I researched JSON and created the system from scratch instead of using a ready-made plugin. This allowed us to add optional conversations throughout the game and made the previously quiet Kitty City area feel much more alive.
The Steam release became its own production challenge. Publishing involved much more than uploading the final build. We needed correctly formatted store materials, descriptions, tags, ratings and promotional assets. When some of our materials were rejected, I treated them as release blockers, worked out what had to change and coordinated the new versions with the artists.
Gameplay
The player explores several stylised locations, talks to different characters and completes quests to continue through the story.
The main gameplay features include:
-
Top-down 3D exploration
-
Story-driven quests
-
Optional NPC conversations
-
Environmental, memory-based and timed puzzles
-
Short parkour sections
-
Collecting and delivering quest items
-
Keyboard and controller support
-
Automatic and manual saving
-
Animated story sequences
-
Voice acting
-
Different locations with their own characters and challenges
Each part of the game has its own small story and gameplay idea. The player might help a character, find a missing item, solve a puzzle or complete a parkour route before moving on. The controls were kept simple so players could focus mainly on the story, characters and atmosphere.
Playtesting Feedback
During development, we regularly played through new versions to check whether the quests, dialogue, puzzles, transitions and parkour sections worked together.
A lot of the testing focused on integration. A system could work correctly on its own but still cause problems after it was connected to animation, UI, dialogue or another part of the progression.
After release, Steam reviews and player comments gave us feedback from people outside the development team. Players especially liked the colourful graphics, music, animations, dialogue and emotional story. The main criticism was related to the parkour section. Some players found it too difficult or frustrating compared with the rest of the game. Players also found several smaller visual and gameplay bugs that we had not caught before release.
I used this feedback during post-release development. I improved the parkour section, fixed reported bugs and continued polishing the game after publication.
The feedback showed me how easy it is for developers to become used to their own game! Problems that feel minor or obvious to the team can be much more noticeable to someone playing for the first time.
Outcome
We completed Scaredy Cat and released it on both Steam and itch.io. It became the first Steam release for everyone on the team. The game reached more than 800 wishlists and received positive feedback for its visual style, atmosphere, dialogue, music and emotional story.
The final version included several unique locations, a complete narrative, varied quests and puzzles, parkour sections, optional conversations, animated scenes, voice acting, saving and keyboard and controller support.
Although the project began as a summer course, we took it through the full development cycle: concept development, planning, production, remote collaboration, integration, testing, store setup, submission, public release and post-release support.
For me, Scaredy Cat became my strongest example of working as a producer while also understanding and contributing directly to development.
What I Learned
Scaredy Cat taught me that production is not only about making a schedule or assigning tasks. It is also about understanding how the work of different people connects and noticing when a missing asset, unclear responsibility or technical issue could block the entire project.
I learned how important communication becomes when a team moves from working together in person to working fully online. People need to understand what is expected, what has changed and which parts of their work depend on someone else.
The project also gave me more experience working across disciplines. I needed to understand programming, art, animation, UI, audio and narrative well enough to help connect them, even when I was not personally creating every part.
Setting up the Steam page taught me how much work happens outside the game build itself. Store requirements, promotional materials, descriptions, tags, ratings, submissions and unexpected rejections all need to be handled before the game can reach players.
Continuing development after release also taught me how to work with public feedback. I needed to look at criticism objectively, decide which issues should be prioritised and prepare improvements without losing the original idea.
Most importantly, Scaredy Cat showed me that I enjoy taking responsibility for the full life of a game, from the first concept and team planning to publishing, player feedback and post-release updates.