“I wanted to know how games were made, how characters came to life, how stories were written and how the magic happens backstage.”
For more than eight years, Mihaela Turianu worked in Quality Assurance in the video game industry.
Her job was to test games.
To find problems.
To think about what players might do that developers hadn't expected.
To look at systems from different angles and help make games better.
But behind all that testing was a curiosity that had existed since childhood:
What actually happens backstage to make a game come to life?
Today, Mihaela is exploring the other side of that process.
Instead of testing games created by others, she's learning how to build her own.
Her journey into indie game development is taking her through Unreal Engine 5, Blueprints, gameplay systems, animation, physics, debugging and, perhaps most importantly, the challenge of turning an idea into something another person can actually play.
From Sega to Game Development
Mihaela's fascination with games started long before she entered the industry.
As a child, she didn't have a PC, but she had a Sega console that fascinated her.
As technology evolved, she experienced games across different generations—from older consoles and Commodore 64 games running from cassette tapes to games on an Intel Pentium 1 PC, the first Xbox and eventually today's powerful gaming hardware.
The technology changed.
The fascination didn't.
But eventually, playing games wasn't enough.
Mihaela wanted to understand what was happening behind the screen.
How were games made?
How did characters come to life?
How were stories created?
How did all the systems come together?
That curiosity eventually led her to apply to Electronic Arts as a Game Tester around 2016.
That was the beginning of her professional journey in the video game industry.
Eight Years on the QA Side
Over the years, Mihaela progressed through different roles and met people working across many areas of game development.
That experience brought her closer to the process she had always wanted to understand.
The people she met along the way also played an important role.
Their encouragement, guidance and insights helped give her the confidence to pursue something she had been thinking about for a long time:
making games herself.
After years of testing games, Mihaela decided to move to the other side of the process.
From finding bugs to creating features.
From evaluating mechanics to building them.
From asking whether something works to figuring out how to make it work in the first place.
Seeing Games Through Three Perspectives
Mihaela's QA background continues to influence how she approaches development.
When she builds a mechanic, she doesn't look at it only from the perspective of the developer.
She thinks about the:
Developer.
Tester.
Player.
A mechanic might work exactly as intended during a normal test.
But what happens when the player does something unexpected?
What if they interrupt an action?
What if they repeat it?
What if they use two systems in an order the developer didn't anticipate?
These questions come naturally from her QA experience.
She also pays close attention to how systems interact.
A feature can work perfectly on its own and still behave differently when it connects with inventory, player statistics, quests or other gameplay systems.
QA has made this way of thinking a habit.
And that habit is now part of how she develops her own games.
Building in Public Through Devlogs
Mihaela isn't waiting for her game to be finished before sharing it.
Instead, she's documenting the process through development logs.
For her, getting a system working is already a milestone worth sharing.
A devlog provides an opportunity to show progress, connect with other developers and players, and get different perspectives while the project is still evolving.
It also means showing the unfinished parts.
The bugs.
The experiments.
The trial and error.
The moments where something that looks simple from the outside takes much longer to get working than expected.
That's an important part of Mihaela's approach.
She's still learning.
She's still experimenting.
And she wants her devlogs to reflect that honestly.
Perhaps someone watching her journey will recognize a problem they've experienced themselves.
Or maybe a small breakthrough will encourage someone working on their own project.
For Mihaela, the process itself is part of the story.
Finding Her Way to Unreal Engine 5
Mihaela didn't begin with Unreal Engine.
She initially tried Unity.
But she struggled with coding, which made it difficult to turn her ideas into working gameplay.
Later, changes to Unity's pricing also made her question whether it was the right choice for someone developing on a very limited budget.
Unreal Engine offered something that made the process more approachable:
Blueprints.
Its visual scripting system allowed Mihaela to build gameplay logic visually.
She still needed to understand how the underlying logic worked, but she didn't have to become blocked by code before she could start experimenting.
That changed the learning experience.
Instead of spending all her time fighting the programming language, she could focus on understanding systems and seeing her ideas become playable.
Free documentation, YouTube tutorials and helpful Discord communities have also played an important role.
There has still been plenty of trial and error.
But being able to take an idea, build it and see it working inside the game has made the learning process rewarding.
When Dropping an Item Isn't Simple
One of Mihaela's recent development challenges came from something that sounds incredibly simple:
dropping an item.
The basic idea seems straightforward.
Remove an item from the inventory.
Make it appear in the game world.
Done.
Except it wasn't.
Physics and collision behaviour introduced unpredictability.
Sometimes an item would fall through the ground.
The frustrating part was that the problem wasn't always consistent.
An item might work perfectly in one test and disappear in the next.
That made the underlying problem much harder to identify.
Because Mihaela uses a shared, data-driven system for dropped items, the solution also needed to work across different objects.
The experience reinforced an important lesson from her QA background:
One successful test doesn't necessarily mean a system is ready.
There was another layer to the problem as well.
After using or dropping an item, the inventory entry could remain visible.
The selected entry could still point to something that no longer existed.
The item details could fail to update correctly.
Each individual action seemed simple.
But they all affected the same interface.
Mihaela learned that building an inventory isn't simply about storing items.
It is about managing the relationships between the different systems that depend on those items.
Making Mechanics Feel Good
Mihaela's recent devlogs include systems for sprinting and stamina, player illumination and interaction awareness.
But getting a mechanic to technically work isn't enough.
She wants mechanics to feel intuitive.
When developing something, she asks herself questions such as:
Would I enjoy this as a player?
Would I find it interesting?
Would it help me?
Would I naturally understand how to use it?
Those questions influence not only individual mechanics but how the mechanics connect with each other.
Controls should make sense.
Feedback should be clear.
Systems should feel comfortable together.
And if something feels awkward, she plays with it and adjusts it.
For Mihaela, development isn't finished simply because the feature works.
It also needs to feel good to use.
Technically Correct Doesn't Always Mean Enjoyable
One of the distinctions Mihaela makes is between a feature being technically complete and a feature being enjoyable.
Technically, a feature is complete when it does what it is supposed to do consistently—including when a player does something unexpected.
Enjoyment is different.
There is no formula that guarantees every player will enjoy a mechanic.
Instead, Mihaela steps back from the implementation and simply plays with it.
Do the controls feel natural?
Is the response clear?
Does the mechanic become frustrating?
Does it become repetitive?
Does the player understand what the game expects from them?
Knowing exactly how a system was built can make it easy for a developer to overlook things that aren't obvious to someone experiencing it for the first time.
Sometimes something works perfectly and still feels wrong.
That's when Mihaela is willing to simplify, adapt or rethink the feature.
The goal is to let the player enjoy the game without having to stop and figure out how the game expects them to play.
Learning Animation the Hard Way
Another example came from something as simple as making a character bow when the player entered an area.
The idea sounded straightforward.
The implementation wasn't.
Mihaela needed to transfer an animation between characters with different skeletons and starting poses.
Some of the movement didn't transfer correctly.
The character's arms looked awkward.
She worked through the retargeting process step by step.
She checked how the bones were mapped.
She adjusted the pose alignment.
She experimented with the setup.
After several rounds of adjustments, she finally got the bow looking close to what she wanted.
The process taught her more about animations, skeleton mapping, bone hierarchies and retargeters.
And when the character finally performed the gesture correctly, it was a small but satisfying victory.
Progress Doesn't Always Look Exciting
Indie development requires more than learning technology.
It requires maintaining motivation when progress is slow.
Mihaela tries to handle that by taking things one manageable step at a time.
Rather than trying to learn everything Unreal Engine can do, she focuses on learning what she needs for the feature she is currently building.
That gives the learning a practical purpose.
Some days are about adding something new.
Other days are spent figuring out why something that worked yesterday suddenly doesn't work anymore.
Those days can be frustrating.
But solving a problem is still progress, even if it doesn't make an exciting devlog.
What keeps Mihaela motivated is seeing the game gradually take shape.
A working interaction.
An animation finally behaving properly.
A small environmental detail that makes the world feel more alive.
Those moments provide the motivation to keep going.
She also has a simple strategy for preventing the process from becoming overwhelming.
After spending hours or days working on Blueprints and logic that may not be visually exciting, she gives herself around 15 minutes to create something visual.
Falling leaves.
A door opening.
A small environmental effect.
Something simple that immediately changes what she sees in the game.
It may only take a few minutes, but it can provide a useful reminder of why she's building the game in the first place.
From Testing Games to Understanding Their Complexity
One of the biggest surprises of becoming a developer has been discovering just how much work goes into things that appear simple when playing a finished game.
Picking up an item sounds like one action.
But implementing it can involve:
- Interaction logic
- Inventory data
- UI updates
- Object spawning
- Physics
- Collision
- Selection state
- Communication between different systems
In QA, Mihaela was used to examining what already existed and finding where it didn't behave as expected.
As a developer, she now starts with an idea and has to work out all the decisions required to turn that idea into something functional.
That has given her a much greater appreciation for the work behind the games she has tested throughout her career.
And it has also made development surprisingly rewarding.
A small feature can feel like a significant achievement when you know exactly what it took to make it work.
The Game She Wants to Build
Mihaela isn't rushing to reveal every detail of the game she ultimately wants to create.
She's giving herself room to experiment and allowing the project to take shape naturally.
But the vision is clear.
She wants to create a world that people enjoy spending time in.
A world that keeps players curious.
A world where they can explore and discover things at their own pace.
For her, one meaningful milestone would be having a playable version that she feels comfortable putting into someone else's hands.
Not simply something that works.
Something that another person can play and genuinely enjoy.
Seeing someone have fun with something she created would mean a lot.
Advice for Developers Making the Transition
For people working in QA or other areas of the gaming industry who are considering moving into development, Mihaela offers realistic advice.
Think carefully about the decision.
The journey can be difficult and tiring.
Specific problems can be surprisingly hard to research.
Tutorials can leave unanswered questions.
Documentation can be difficult to follow when foundational knowledge is missing.
And there is no guarantee that an idea will find an audience.
But there is another side to it.
Building something of your own can be incredibly rewarding.
There is a unique feeling in seeing an idea become something you can actually play.
Her advice is to start small.
Build a mechanic.
Build a small playable project.
Give yourself room to learn.
Before committing to a huge game, find out whether you actually enjoy the day-to-day work of making games—not just the idea of being someone who makes games.
And keep expectations realistic.
The internet can be unforgiving, and people can be ruthless sometimes.
The goal should be to learn, build and keep moving forward.
What's Next?
Mihaela is continuing to build and document her indie development journey.
Her current work includes gameplay mechanics, interaction systems, animation, inventory systems, physics and other pieces that will eventually come together into a larger playable experience.
She's still learning.
Still experimenting.
Still debugging.
And still figuring out what the game will ultimately become.
That's what makes her journey interesting.
She isn't presenting a finished success story.
She's showing what happens when someone who spent years testing games decides to step behind the curtain and try to build one.
From QA to development.
From finding bugs to creating systems.
From playing games to making them.
The journey is only beginning.
About Mihaela Turianu
Mihaela Turianu is an indie game developer with more than eight years of experience in Quality Assurance within the video game industry.
She is currently building games with Unreal Engine 5, using Blueprints and exploring gameplay systems, animation, interaction, physics and game design.
She documents her development journey through devlogs under the name MTIndieDev.
View Mihaela's profile on CoderLegion
Follow MTIndieDev on YouTube
CoderLegion Developer Stories
Real developers. Real journeys. Real experiences.
Developer Stories at CoderLegion gives developers an opportunity to share how they think, what they build, the problems they encounter and what they learn along the way.
Interview & Story by Mehadi Hasan
