Assessment Tracks
Review each role family, competency focus, and fit profile so you can choose the path that matches your strengths, growth goals, and the team behaviors required to build trust, clarity, accountability, and shared results in that role.
Support role group
You live in the ticket queue: reproduce bugs, collect logs, read stack traces, and keep escalations moving before customers churn.
Good support engineers write clean repro steps, route issues to the right owner, and close the loop with plain-language updates. The best ones turn repeated cases into KB articles and faster runbooks so the same fire does not happen twice.
You run onboarding calls, map requirements, and guide proofs of concept that have to work in real customer environments.
You spot integration blockers early, translate product limits honestly, and keep implementation plans tied to go-live dates. Strong solutions engineers prevent renewal risk by showing clear time-to-value, not by winging polished demos.
You clear the daily queue: password resets, MFA lockouts, VPN failures, printer chaos, and laptops that stop working ten minutes before a deadline.
Great desk engineers prioritize by business impact, not ticket noise, and escalate fast when root cause sits outside their lane. They keep SLAs honest, document fixes, and get people back to work without drama.
Provides a work-style profile for non-technical professionals who want clearer collaboration and growth direction.
Personality axis fit is the primary output, showing communication, planning, and stakeholder tendencies in daily work. Competency axis is intentionally excluded in this path, so role-fit conclusions remain personality-focused rather than technical.
Maintainer role group
You carry the pager, watch error budgets, and decide whether to ship or freeze when risk climbs.
You run incidents to reduce blast radius, write clear postmortems, and turn lessons into runbooks and automation. Strong SREs cut toil, improve on-call handoffs, and keep services boring in production.
You keep core systems alive: AD issues, DNS weirdness, VPN failures, patch windows, and the switch that dies at the worst time.
You manage server health, network changes, and access controls without breaking business hours. Great admins document repeat fixes, tighten change control, and keep recovery steps ready before outages happen.
You own backup jobs, restore windows, index health, and the query plan that suddenly got slow after last deploy.
You watch replication lag, tune hot queries, and keep failover paths ready before anyone asks for them. Strong DBAs protect data first, then performance, and can explain the tradeoff in plain language when pressure is high.
You work the queue through alert fatigue, separate false positives from real threats, and escalate fast when dwell time starts to grow.
You correlate logs, capture evidence, and hand off clean incident notes so containment moves quickly. Strong SOC analysts keep detection quality high without drowning the team in noisy alerts.
Builder role group
You pick up tickets, break work into small PRs, and ship features without blowing up production.
Daily work means debugging stack traces, writing tests, reviewing code, and fixing regressions before users find them. Strong application engineers leave the codebase cleaner after each release, not messier.
You build internal and customer-facing apps, wire APIs, and keep auth flows from turning into a security hole.
The real job is shipping features while protecting trust boundaries, input handling, and session behavior. Strong application developers can explain risk in plain terms and still hit delivery dates.
You own the hairy projects: cross-service changes, migration plans, and incidents nobody else wants to touch.
You review design docs, mentor mid-level engineers, and set guardrails for dependencies, secrets, and failure modes. Great senior developers reduce rework by making hard tradeoffs early and documenting why.
You ship screens that load fast, stay accessible, and do not break during hydration.
You care about bundle size, paint performance, state bugs, and the tiny interaction details users notice right away. Strong frontend engineers can balance design polish, browser reality, and maintainable component structure.
You design service boundaries, own APIs, and keep downstream teams from getting paged by your changes.
The work includes schema changes, latency budgets, queue behavior, and debugging production incidents from logs and traces. Strong backend engineers make systems boring to operate and easy for other teams to build on.
You ship iOS and Android features through store review, crash triage, and release deadlines that do not move.
Daily work includes offline behavior, device quirks, startup time, and push-notification edge cases. Strong mobile engineers keep app quality stable across versions while still shipping on cadence.
You build pipelines that move raw events into tables people can trust for decisions.
The job is orchestration, schema evolution, late-arriving data, and fixing broken jobs before dashboards lie. Strong data engineers care about lineage, data quality checks, and predictable batch or streaming runs.
You move models from notebook experiments to production endpoints that real users hit.
The work is feature pipelines, eval quality, inference latency, prompt or model drift, and rollout safety. Strong ML engineers treat monitoring and guardrails as part of the product, not an afterthought.
You own CI pipelines, deployment templates, and the rollback button when a release goes sideways.
Daily work is pipeline flake cleanup, secrets handling, IaC changes, and reducing manual release steps. Strong DevOps engineers help teams ship faster without increasing incident load.
You build test coverage that catches regressions before production does.
The job is writing automation, isolating flaky tests, reproducing bugs, and pushing for release gates that actually protect users. Strong QA engineers know where risk lives and focus coverage there first.
Architect role group
You define target state architecture, set guardrails, and stop teams from rebuilding the same thing five ways.
Daily work is reference architecture, integration boundaries, migration sequencing, and hard tradeoffs between speed and long-term maintainability. Strong enterprise architects make standards that teams actually use, not shelfware.
You run discovery, map business requirements to system design, and turn messy asks into buildable architecture.
The job is integration patterns, API contracts, non-functional requirements, and rollout plans teams can execute. Strong solutions architects prevent expensive rework by surfacing constraints before implementation starts.
You model threats, define control baselines, and review designs before risk ships to production.
Daily work means IAM patterns, trust boundaries, key management, and security exceptions that need clear compensating controls. Strong security architects reduce attack surface without blocking delivery for months.
You define canonical models, warehouse layering, and data contracts that stop every team from inventing new definitions.
The job is schema strategy, lineage, retention rules, and governance decisions that survive team turnover. Strong data architects keep reporting trustworthy while the platform scales.
You define landing zones, network boundaries, IAM structure, and platform guardrails before app teams deploy.
Daily work is resilience patterns, cost controls, capacity planning, and decisions about what belongs in shared platform versus app space. Strong cloud architects make the default path secure, scalable, and hard to misuse.
Management role group
You set portfolio bets, own major vendor spend, and decide where headcount and budget move next quarter.
The job is executive alignment, operating cadence, and hard tradeoffs when every team says their roadmap is critical. Strong VPs turn strategy into accountable delivery across business units, not slide decks.
You run the weekly operating rhythm: unblock team leads, reset priorities, and keep commitments realistic against capacity.
The role is less about heroics and more about staffing plans, escalation handling, and cross-team handoffs that do not break. Strong senior managers make execution predictable even when priorities shift.
You own multi-team roadmaps, hiring plans, and budget calls where every choice has a downstream cost.
Daily work includes quarterly planning, executive updates, and removing bottlenecks that stall strategic programs. Strong directors build managers, set clear accountability, and keep cross-functional work moving under constraint.