Best Practices

• Use real-world metaphors. A skiing game where you tilt to dodge trees requires zero explanation. A ball-rolling game where you tilt to navigate a maze is immediately understood. When the game’s premise maps to a real-world experience, the controls and hazards are self-evident.
• Make hazards visually obvious. Players cannot avoid what they cannot identify. Hazards must differ from targets in color, silhouette, size, or motion pattern — not just in name. Use universally understood threat signals: spikes, red coloring, aggressive movement patterns, warning symbols.
• Align perspective with gesture direction. When the camera angle and movement direction match the player’s natural gesture orientation (e.g., tilting left to steer left), controls feel invisible. Players focus on the game, not on learning how to play it.
• Show, don’t tell. If your game requires a specific gesture (tap, swipe, drag, hold), demonstrate it through animation — show both the gesture and its in-game result simultaneously. Text instructions like “swipe to jump” are frequently misinterpreted. An animated hand performing the gesture is far more effective.

• Rule violations: When a player makes a mistake (hitting a hazard, missing a target, running out of time), the consequence must be immediately visible and clearly linked to their action. A subtle life-counter decrement is not enough — use screen flashes, sound effects, character reactions, or other unmistakable signals. If the player doesn’t understand why they failed, they’ll blame your game instead of trying again.
• Off-screen rules: If your game penalizes players for objects leaving the screen (e.g., missing a falling item), this rule must be explicitly taught. Players will not infer off-screen consequences on their own.
• Interactive vs. decorative elements: Every visual element must clearly signal whether it is interactive or decorative. Circular, centered, or animated elements carry strong “button” affordance — if something looks tappable, players will tap it. Use a consistent visual language: interactive elements should be bordered, elevated, or highlighted; decorative elements should be flat and muted. When a player taps something decorative and nothing happens, it erodes their confidence in the game’s responsiveness.
• Meaningful interactions: If your game has a button, tapping it must produce a visible, perceivable effect. Interactive elements with unclear or invisible outcomes feel broken and destroy player agency.

• Demonstrate the core mechanic through guided interaction, not just text.
• Use animated gesture demonstrations (a hand performing the gesture) rather than text-only instructions.
• Be completable in under 30 seconds.
• Be skippable for returning players.
• Cover essential controls and objectives without overwhelming the player.

• Gradual ramps: Each difficulty increase should feel like a natural extension of the previous level, not a sudden wall.
• Perceived fairness: Players need to feel that failure is their fault, not the game’s. Difficulty spikes that feel arbitrary or insurmountable break the re-engagement loop.
• Learnable failure: Every failure should teach the player something. When a player can’t understand what they did wrong, they won’t come back.

• Create spending pressure: Escalating enemy waves, time pressure, score multipliers, or efficiency ratings should make resource deployment feel necessary — not optional.
• Avoid passive play: If a player can succeed by watching rather than actively engaging, the game isn’t challenging them enough. Design the difficulty curve so active engagement is always the optimal strategy.
• Balance the economy: Ensure the relationship between earning and spending stays tight enough that spending choices matter throughout the entire game loop. When resources accumulate without purpose, players disengage.

• Map to known gestures. Before designing controls, consider which gestures players already know from comparable games. Map your core mechanics to well-known gestures; reserve novel gestures for secondary or optional controls.
• Calibrate input sensitivity. Overly sensitive controls punish natural player behavior and create a perception of unfairness. Input sensitivity for continuous-control mechanics (steering, tilting, dragging) must be tested with representative players on a range of devices. Consider offering sensitivity settings to accommodate different play styles.
• Make different controls visually distinct. If your game uses multiple input types (tapping and dragging), their visual controls must look distinctly different. A flat circle reads as a tap button, even if it’s meant to be dragged. Use 3D rendering, shadows, or directional indicators to signal drag/joystick controls. If one side of the screen uses tap buttons and the other uses a joystick, their styling should make the difference self-evident.

• Test gesture-based controls on devices with different screen sizes — a swipe that works on a large screen may be too cramped on a 5-inch phone.
• Test tilt/accelerometer controls on multiple devices, as sensitivity varies between manufacturers.
• Consider that players with different hand sizes and grip styles may interact with your controls differently.

• Minimize initial bundle size. Keep your initial bundle under 5 MB when possible. Defer loading non-essential assets until after the game has started.
• Use progressive loading. Load critical assets first (splash screen, core gameplay assets), then load additional assets in the background during gameplay.
• Compress assets aggressively. Use texture compression, audio compression (OGG/MP3 rather than WAV), and minified JavaScript.
• Report loading progress. Use FBInstant.setLoadingProgress() to keep the player informed during loading. A moving progress bar reduces perceived wait time.

• Audit your assets. Remove unused images, sounds, and code. Use tools to identify and eliminate dead assets.
• Choose efficient formats. Use WebP for images, compressed audio formats, and minified/bundled JavaScript.
• Lazy-load non-critical content. Levels, additional characters, and secondary content can be loaded on demand rather than included in the initial bundle.

1. Leaderboards — Show friends’ scores at natural break points (end of round, game over screen). Leaderboards create friendly competition that drives repeat sessions.
2. Sharing — Let players share notable achievements, high scores, or gameplay moments to their Facebook feed. Each share is a potential acquisition event.
3. Challenges — Enable players to challenge specific friends. Challenges create direct, personal re-engagement loops.
4. Tournaments — Create time-limited competitive events that drive concentrated engagement. Tournaments are particularly effective for retention.

• Record a player’s best moment, not just their final score.
• Create visually appealing share images or videos.
• Include a clear call-to-action that encourages the viewer to play.
• Personalize shared content with the player’s name or avatar.

• Show personalized leaderboards featuring friends.
• Suggest friends to challenge or invite.
• Display friends’ progress or achievements within the game.

• Rewarded videos: Offer at moments where the player receives clear value — an extra life, a score multiplier, bonus currency, or a hint. Rewarded ads have the highest player acceptance and generate strong eCPMs. Important: The reward must be immediately visible and clearly impactful after the ad completes. If a player watches a 30-second ad and can’t perceive the benefit, they won’t watch another.
• Interstitial ads: Show between levels, after a game-over, or at other natural transition points. Avoid showing interstitials during active gameplay or too frequently (no more than once every 30 seconds).
• Banner ads: Display during menus, loading screens, or other non-gameplay moments. Banners generate lower revenue per impression but provide a steady baseline.

• Near-miss revival: “Watch to continue” after a close loss where the player was emotionally invested.
• Visible power-ups: Bonuses that have an immediate, dramatic effect on the next round.
• Time-limited boosts: Multipliers or shields that last for a specific, visible duration.

• Offer a range of price points, from small impulse purchases (under $1) to premium bundles.
• Ensure that purchased items provide clear, visible value.
• Use limited-time offers and bundles to create urgency.
• Never force purchases to continue playing — this drives churn rather than revenue.

• A game icon that is distinctive, readable at small sizes, and representative of your game.
• A cover image that showcases actual gameplay (not just logos or characters).
• A gameplay video that demonstrates the core experience in the first few seconds.

• Maintain a high Day 1 and Day 7 retention rate.
• Encourage social interactions (shares, challenges, tournament participation).
• Update your game regularly with new content.
• Respond to player feedback and fix bugs promptly.

• Daily rewards: Offer escalating daily login bonuses to incentivize consecutive-day returns.
• Progress systems: Levels, unlockables, and skill-based progression give players a reason to continue.
• Social competition: Leaderboards and tournaments create ongoing competitive motivation.
• Content updates: New levels, events, and seasonal content keep the experience fresh.

• Send notifications that are timely and relevant — a friend beating their score, a tournament starting, or a reward expiring.
• Deliver on the promise. When a player taps a notification, the game should immediately surface the context that was promised. If a notification says “Your friend beat your score!”, the leaderboard showing that friend’s score should be the first thing the player sees. Broken promises between notification content and in-game experience erode notification credibility over time.
• Avoid generic “come back and play” messages.
• Limit notification frequency to avoid fatigue.
• Personalize notifications with context (friend names, specific game events).

• No tutorial or unclear onboarding.
• Missing basic UI elements (volume control, pause button, back navigation).
• Excessive or poorly timed ads.
• Poor performance or crashes on common devices.
• Assets that do not meet design guidelines.

• Test on multiple devices (iOS, Android, web) and screen sizes.
• Test with slow network connections to ensure graceful degradation.
• Test the complete player flow: discovery, loading, tutorial, gameplay, monetization, sharing, and re-engagement.
• Test gesture-based controls on different screen sizes and with different grip styles.
• Use test users to verify social features work correctly.

• Quick Start — Start building your first Instant Game.
• Game Performance — Deep dive into loading and runtime optimization.
• Building Social Games — Comprehensive guide to social feature integration.
• Monetization Best Practices — Detailed monetization strategy guidance.