Whether you’re a solo app developer or an accomplished studio with dozens of titles under your belt — anything can (and will) go wrong at some point and potentially turn your project into a house of horrors. A last-minute bug might derail your deadline by hours before release, or your rock star developer gives notice and jumps ship — or just as you’re ready to push out your next game title, one of your playable ads is bugging out and you have no idea why.
As cringe-worthy as these experiences may be in hindsight, every major misstep is an opportunity to adapt, learn, and improve business and development processes to prevent your next project from turning into a frightful experience.
So gather ‘round boys and ghouls, here are some stories from veteran developers and designers who have literally seen it all at PeopleFun’s Wordscapes Search and SparkLabs, and some tips on how these nightmares can be avoided — not listed in the order of lost sleep they may cause you.
Horror Story #1: Invasion of the Release Blockers
You’ve been working hard on your newest release and the team really pulled together to deliver an exceptional product. All that’s left are the last few approvals and SURPRISE! A release blocking bug surfaces for the first time. Developers are often so focused on the immediate tasks right in front of them that sometimes large bugs slip by, and few things make a developer’s heart drop faster. In some cases it can be an easy five-minute fix, but in the occasional horrifying scenario, it becomes something infinitely more complex and time consuming.
How to manage this:
What’s important is that you and your team are aware of the implications early enough so you can properly triage and eliminate as many high priority bugs as quickly as possible.
- Perform code reviews and test early and often.
- Encourage everyone to get in the habit of playing the latest build of your project daily.
- Train yourself to look at every aspect of your release like it’s the first time you’re seeing it. In the midst of heavy development, it’s easy to ignore things right in front of you when you see them everyday.
- Get builds reviewed by the Quality Assurance team as soon as possible. This ensures they have a much more thorough understanding of the product and its desired functionality. It also serves to flag potential bugs and other issues early so they can be addressed over the course of development, rather than last minute.
Horror Story #2: The Terrifying Tale of Team Shakeups
Team chemistry is one of the most important factors in any project’s success. It’s a magical but fragile thing. Finding the right combination of talents, personalities, and skills for any team can be difficult, and even after you’ve managed to capture lightning in a bottle, it can be even more challenging to keep it there. Losing just one person, let alone several, can cause a major disruption to development and timelines as you rework pipelines and shift tasks and schedules to account for the inevitable decrease in momentum.
How to manage this:
While there are many things you can do to avoid team shake-ups, such as maintaining high morale and keeping the project fun to work on, the loss of valuable team members is (more often than not) out of your control. Because of this, the most important thing is how you prepare and then respond to change when it happens.
- Lay the groundwork by ensuring that everyone on the team is sharing information about their work openly.
- Avoid having team members work in isolation.
- Encourage your engineers to review each other’s code, and artists on your team to get feedback from one another.
- Let the team know about a personnel shift as early as possible and avoid secrecy.
- Make an honest assessment of the impact staff changes will have on your team and prepare for the ramifications.
Horror Story #3: Attack of the Missed Release Dates
In an industry where time and money are so vital to everything we do, missed or delayed release dates are a nightmare. All too often, we find ourselves in the last stretch of development with too much work to do and too little time, especially with a new feature or a holiday-themed event. This puts us in the uncomfortable position of making a difficult decision. Either we need to cut part of a feature the team was excited about or delay the release date, which increases cost and risks the feature’s relevance. In addition, the weight of tight deadlines can have long-term detrimental effects on the overall health of the team and can lead to increased tension, stress, and burnout, which inevitably hurts the quality of the game.
How to manage this:
Luckily, most of the heartache, anxiety, and costs surrounding missed deadlines can be avoided with some smart, thoughtful planning. When a new release is coming down to the wire and is in danger of slipping, there are a few culprits that are often responsible:
- Miscalculated time estimations can be a project killer. Most teams are exceptionally good at estimating the amount of time required to complete a specific task, but they’re less good at accounting for the additional miscellaneous tasks that always arise in any development environment.
- Beware of scope creep delays that occur when going from a design document to the final release.
- Take the time to properly plan and architect before starting to build. This will save a significant amount of time and make development go much smoother in the long run.
- Always speak with department leads to determine their estimates before locking into a specific decision on any new task.
Horror Story #4: Revenge of the Playable Ad
There are any number of things that can drive developers to run screaming into the night, and this is a particularly gruesome one. During the QA process, someone on the team discovers that the game freezes when certain interactions are performed and you have no idea why. There are a lot of moving parts when it comes to playable ad development. One of the worst situations is when your ad is about to go live and there’s a glitch. The tough part is that working remotely makes solving for bugs even more challenging. They’re harder to recreate and share information that will help the team get to the root cause of why it’s happening in the first place — quickly. This can lead to a lot of last minute chaos and uncertainty.
How to manage this:
If a bug happens at a certain part of the game with a playable ad, narrow down where it’s happening and all the related interactions. Ask for help from teammates, communicate common pitfalls, and consider the following:
- Retrace your steps.
- Search the code and console log and check if things are happening out of order.
- Check all animations. Maybe an animation is starting or stopping when it shouldn’t be.
- Consider simplifying your code to see if the bug gets fixed so you can narrow down what’s happening.
- When testing a teammate’s work, record your screen. This way, if a bug happens, the developer can understand which interactions led to the bug occuring.
Horror Story #5: Invasion of the Monstrously Large Files
This tale is particularly frightening for anyone on the last stretch of mobile app development. The designers have created the mocks, exported the assets, and then handed it over to the developers to create a playable ad, only to discover at the last minute that the file size exceeds the upload requirements. Suddenly everyone is scrambling to mitigate the file size before shipping. If it’s an animation sequence, the frames need to be compressed. If that doesn’t work, they may need to cut frames out, resulting in choppy animation. Even worse, they might have to scale down the assets and re-export, which is a huge ordeal and a process to avoid at all costs, especially if this all comes crashing down right before deadline.
How to manage this:
It can be hard to tell at the beginning of the project how big your assets will be, especially when there are additional requests for added functionality and effects during the QA process. You know how many image sequences you’ve planned for, but file size can be tricky to determine at that early stage. Here are a few things to consider:
- Pre-plan across marketing, design, and development stakeholders.
- Depending on project parameters and creative assets, design decisions and compromises need to be made at the beginning of the project to keep file sizes from ballooning.
- Consult developers early in the concepting phase so they can add input on anything that could boost file size out of scope.
- Compress images and shorten audio after all the bugs are worked out and creative design tweaks have been made.
- See if any PNG files can be turned into JPEGs to reduce file size. If the file doesn’t have any transparency, it’s safe to convert into a JPEG.
- Automate tedious tasks like cutting frames and resizing files.
Don’t let these horror stories happen to you! Happy Halloween from AppLovin!
