DEV Community

Anthony KOZAK
Anthony KOZAK

Posted on Originally published at exoa.dev

How Do You Run a Quarterly Career Review as a Game Developer?

Game development careers rarely move in a straight line. Engines change, studios reorganize, platforms mature, and new tools alter what teams expect from developers. A quarterly career review provides a repeatable way to examine that movement without reacting impulsively to every announcement, difficult sprint, or new technology. The goal is not to predict the industry. It is to make your next professional decision using current evidence instead of an outdated picture of your skills.

Key Takeaways
  • Review your career every quarter using evidence, not mood or job titles alone.
  • Track decisions, constraints, verification, and outcomes while project details are still fresh.
  • Audit skills for proficiency, recency, evidence, and relevance to a specific direction.
  • Choose a small set of 90-day goals with explicit definitions of done.
  • Set decision triggers before pressure makes every option look urgent.

Why Should Game Developers Run a Career Review Every Quarter?

A quarterly career review is a structured checkpoint between daily execution and major career decisions. Weekly reflection is often too close to the immediate pressure of a project, while an annual review can leave weak signals unnoticed for months. A quarter is long enough to complete meaningful work and short enough to correct direction before an assumption becomes a long-term commitment.

This matters in the 2025-2026 game industry because technical expectations are moving on several fronts at once. Unity workflows, platform requirements, AI-assisted development, live operations, web services, and VR/XR hardware continue to evolve. None of those changes automatically requires a career pivot. They do require a regular method for separating durable capabilities from temporary noise.

Treat the review as an operating process, not a motivational exercise. It should answer four questions: What changed? What evidence did I create? Which capabilities became stronger or weaker? What deserves focused attention next? A useful review produces decisions, calendar commitments, and a short list of things you will deliberately ignore.

My credited work spans gameplay programming on Eagle Flight Arcade, educational development on Rabbids Coding, the mobile biofeedback game O.Zen, freelance work through Exoa, and more than 16 commercial Unity Asset Store plugins. That range illustrates why a single static label can become inadequate. Projects create different combinations of technical depth, product understanding, communication, and delivery knowledge.

The final output should fit on one page. Record your current direction, strongest evidence, important gaps, next goals, and decision triggers. If the review becomes a long diary with no commitments, it is collecting thoughts rather than managing a career.

What Career Data Should You Collect Before the Review?

Start with a contribution ledger. For each active project, record the problem, your responsibility, constraints, important decisions, and current status. Update it during the quarter rather than reconstructing everything from memory. A commit history can show that code changed, but it usually cannot explain why a technical decision mattered or how your work supported delivery.

Separate activity from evidence. Attending meetings, reading documentation, and experimenting with a package are activities. Shipping a feature, validating a performance hypothesis, documenting a migration, resolving an integration risk, or building a reusable tool are evidence. Both categories can be useful, but only the second demonstrates a capability that another person can evaluate.

Collect feedback in its original context. Save code review themes, retrospective comments, acceptance criteria, support issues, and questions that repeatedly reach you. Repeated requests can reveal an emerging strength. Repeated corrections can reveal a gap. One comment should not define your direction, but a pattern across projects deserves attention.

Include external market signals without treating them as commands. Sample relevant job descriptions, contract briefs, conference programs, platform roadmaps, and documentation updates. Record which capabilities recur and which requirements belong only to a narrow role. This protects the review from being dominated by one viral post or one unusually specific vacancy.

Finally, document constraints. Available learning time, location, schedule, contract obligations, desired working style, and financial needs affect which options are realistic. Constraints are not personal failures. They are design inputs. A direction that ignores them is not ambitious. It is incomplete. The review becomes useful when professional evidence and practical reality appear in the same decision.

How Do You Turn Project Work Into Credible Career Evidence?

Credible evidence explains reasoning, not just output. A portfolio screenshot can establish that something existed, but it rarely shows what you owned. Create a compact evidence card with six fields: context, problem, responsibility, constraints, decision, and verification. Add an outcome only when you can support it. If no quantitative metric exists, use an observable state such as an accepted build, completed migration, reproducible test, or approved workflow.

Capture evidence close to the work. Technical details decay quickly, especially when several Unity projects use similar systems. Architecture decision records, pull request descriptions, profiling captures, diagrams, test plans, and release notes preserve the reasoning that a final build hides. They also reduce the temptation to exaggerate your contribution months later.

A small internal tool can make that habit easier. For example, a ScriptableObject can preserve important Unity architecture decisions beside the project assets:

using UnityEngine;

[CreateAssetMenu(menuName = "Documentation/Architecture Decision")]

public sealed class ArchitectureDecision : ScriptableObject

{

[SerializeField] private string title;

[TextArea] [SerializeField] private string context;

[TextArea] [SerializeField] private string decision;

[TextArea] [SerializeField] private string consequences;

[SerializeField] private string verification;

}

The code itself is not impressive evidence. Its value comes from the records it encourages: why a boundary exists, what alternative was rejected, which tradeoff was accepted, and how the team will know whether the decision works. The same information can later support a case study, interview answer, handoff document, or promotion discussion.

Respect confidentiality. Do not copy client code, internal metrics, private screenshots, or unreleased designs into a public portfolio. Create a sanitized description or an original demonstration that proves the same general capability. Keep a private evidence index with links to approved internal material, and clearly mark what can be discussed publicly. Professional judgment is itself part of the evidence.

How Should You Audit Your Skills in 2026?

A useful skill audit measures more than whether you have encountered a technology. Score each important capability across four dimensions: proficiency, recency, evidence, and relevance. You may understand a subject well but lack recent practice. You may also use a tool every day without having a strong example that demonstrates independent judgment. Those are different gaps and require different responses.

Organize skills into layers. The foundation includes programming, debugging, source control, testing, profiling, and communication. The production layer includes Unity architecture, asset pipelines, build systems, platform constraints, and release practices. The domain layer contains specializations such as gameplay, tools, graphics, networking, mobile, VR/XR, web integration, or technical leadership.

AI-related capability should be evaluated by the quality of the surrounding engineering. Prompt familiarity is not enough. Can you define constraints, inspect generated changes, verify behavior, protect private information, and maintain the result after the initial output? Those questions connect new tools to durable software development skills instead of creating a separate category based on novelty.

Next, compare the audit with a specific target direction. Do not ask whether learning a technology is generally useful. Ask whether it strengthens the type of work you want to perform and whether you can create credible evidence within the next quarter. A small completed integration often teaches more than an ambitious course plan with no application.

I recommend selecting one primary gap and one maintenance skill per quarter. The primary gap should unlock a meaningful capability. The maintenance skill protects something valuable that may otherwise become stale. Everything else goes into a backlog. This limit is important because career progress depends on completed learning loops: study, application, feedback, verification, and explanation.

Which Career Narrative Should Your Evidence Support?

A career narrative is not a slogan or an attempt to make every project look related. It is a concise explanation of the problems you can solve, the environments in which you can solve them, and the evidence supporting that claim. Without this layer, a broad career can look random even when the underlying capabilities are coherent.

Begin with a working sentence: I help a particular type of team solve a particular class of problem using a credible set of capabilities. Keep it narrow enough to be understood but broad enough to survive one tool change. For example, positioning around reliable Unity delivery is more durable than identifying entirely with one package, platform generation, or temporary workflow.

Then create audience-specific views of the same evidence. A hiring manager may need role fit, ownership, and collaboration. An engineering lead may care about architecture, debugging, and tradeoffs. A client may care about risk, communication, and a clear path to delivery. The underlying facts must remain consistent even when the order and level of detail change.

Products can support the narrative when their relevance is explicit. Touch Camera PRO can be discussed as a shipped Unity Asset Store camera controller, while tools such as Assets Manager, Tutorial Engine, or Responsive UI Pro represent different product and tooling concerns. Listing product names alone is weaker than explaining the capability each public artifact allows someone to inspect.

End the quarterly review by checking for narrative debt. Remove claims that no longer have recent evidence. Identify strong work that is missing from your resume, portfolio, profile, or case studies. If your desired narrative and actual evidence disagree, do not solve that with better wording. Make the next quarter produce the missing proof.

Which Goals Belong in Your Next 90-Day Plan?

The next quarter should contain fewer goals than your ambition suggests. I recommend four categories: one delivery goal, one capability goal, one relationship goal, and one optionality goal. They reinforce each other without turning the plan into a second full-time job. Depending on current constraints, some categories can be intentionally small.

A delivery goal completes something observable. It might be a feature, tool, migration, technical article, public sample, or documented performance investigation. A capability goal closes the most important gap from your audit. A relationship goal improves an existing professional connection through useful interaction. An optionality goal preserves a future path, such as updating a portfolio or investigating a neighboring domain.

Every goal needs a definition of done. Replace vague intentions such as learn networking with a verifiable result such as build a small synchronized interaction, document failure cases, and obtain a technical review. Define what will exist, how it will be checked, and where the evidence will be stored. A deadline without acceptance criteria creates urgency but not clarity.

Put the work on the calendar before the quarter starts. Reserve realistic blocks for study, implementation, review, and packaging. Include a stop list that identifies lower-value activities you will postpone. If new work enters the plan, decide what leaves. Otherwise, the quarterly system becomes a growing collection of promises rather than a prioritization mechanism.

Track leading and lagging indicators separately. Scheduled practice and review requests are leading indicators because you control them. Completed artifacts, interviews, responsibilities, and offers are lagging indicators because they depend partly on other people. Judge your process with leading indicators, but use lagging results to test whether the direction is producing useful external signals.

How Can Feedback and Relationships Improve a Career Review?

Self-assessment has predictable blind spots. You may undervalue work that feels easy because you have practiced it for years, or overvalue a new skill because learning it required effort. Feedback provides another view, but only when the question is specific. Asking whether you are doing well usually produces encouragement rather than actionable information.

Ask collaborators which problems they trust you to own, where your communication creates friction, and what responsibility they would assign next. Ask a technical peer to inspect one artifact or decision rather than judging your entire career. Ask someone familiar with your target market whether your evidence demonstrates the level and specialization you intend to claim.

Relationship building should not begin with a request for a job. Share a useful technical note, review a peer's work, make a careful introduction, contribute to an open project, or follow up on a previous conversation with relevant information. Small, credible interactions create context. Mass connection requests and generic public activity create visibility without necessarily creating trust.

Structured guidance can shorten feedback loops when you are changing direction or cannot obtain appropriate review inside your current environment. Options include peer groups, code review, community participation, and one-on-one Unity mentoring and team workshops. The important selection criterion is whether the feedback addresses your actual work and target, not whether it provides more general content.

Record relationship commitments in the quarterly plan. Note whom you should thank, update, support, or ask for focused feedback. Do not treat people as pipeline stages. The purpose is to maintain professional relationships through relevance and reciprocity. At the next review, examine whether your network is becoming more informed about your work, not merely larger.

When Should a Review Trigger a Bigger Career Change?

Most quarterly reviews should produce adjustments, not reinventions. A weak sprint, rejected application, delayed project, or difficult collaboration is not enough evidence for a major pivot. Look for repeated patterns across several sources: declining learning, persistent value mismatch, disappearing demand, health or schedule incompatibility, or a stronger adjacent direction supported by real work.

Classify the available response as deepen, broaden, or redirect. Deepening means increasing expertise and responsibility in the current domain. Broadening adds a complementary capability, such as tooling, web services, production knowledge, or technical communication. Redirecting changes the primary problem, market, or working model. These choices require different evidence and should not be treated as interchangeable.

Set decision triggers in advance. You might require multiple review periods of the same signal, completion of a small experiment, feedback from relevant professionals, or proof that a target role matches your constraints. Predefined triggers reduce the chance that temporary frustration or excitement will control a long-term decision. They also make it easier to explain why you changed direction.

Use reversible experiments before expensive commitments. Build a constrained sample, contribute to a relevant project, take on a neighboring responsibility, or conduct several focused conversations. Evaluate the actual work, not only the identity associated with it. Enjoying the idea of a specialty is different from enjoying its debugging, documentation, constraints, and routine maintenance.

A strong career review ends with a decision and a date. Continue, adjust, test, or prepare a transition, then specify what evidence could change that choice. The system cannot remove uncertainty from a game development career. It can prevent uncertainty from becoming drift. Over time, the accumulated reviews create a clear record of how your capabilities, constraints, and professional direction evolved.

References & Further Reading

Top comments (0)