Interpreting Mobile Developer Test Results: From Scores to Hiring Decisions
Hiring? Get this test scored for you, with integrity signals.Start free
The score tells you nothing without context
Most hiring teams look at a mobile developer assessment score and ask: "Is 72/100 good?" That question is backwards. A score without context is noise.
The only meaningful question is: "For the role we're hiring, what does this candidate actually know and what will they learn?"
Building a rubric first
Before you grade anything, define what good looks like. Without a rubric, you're grading by intuition, and intuition differs from interviewer to interviewer.
iOS assessment rubric example
Code correctness (0–30 points)
- Does it compile? (10 points)
- Do the core requirements work? (15 points)
- Are edge cases handled (errors, state restoration)? (5 points)
Architecture (0–25 points)
- Is state managed clearly (ViewModel separation, no spaghetti)? (10 points)
- Is the code testable (loose coupling, injectable dependencies)? (10 points)
- Is it overengineered for the scope? (5 points)
Knowledge signals (0–20 points)
- Correct use of lifecycle methods (not premature optimization, not leaks)? (8 points)
- Memory safety (no retain cycles, safe unwrapping)? (7 points)
- Async patterns (async-await or Combine, not callback hell)? (5 points)
Code quality (0–25 points)
- Readability and naming? (10 points)
- No obvious bugs or tech debt? (10 points)
- Commits are meaningful (if take-home)? (5 points)
Total: 100 points
Pass threshold: 65–70 (depends on role level)
Android assessment rubric example
Code correctness (0–30 points)
- Does it compile and run? (10 points)
- Core requirements met? (15 points)
- Edge cases handled? (5 points)
Architecture (0–25 points)
- ViewModel and Repository pattern used correctly? (10 points)
- Dependency injection setup (Hilt or manual)? (10 points)
- Appropriate separation of concerns? (5 points)
Knowledge signals (0–20 points)
- Coroutines used properly (not blocking, proper scope)? (8 points)
- Lifecycle understanding evident? (7 points)
- Testing setup (mockito, Espresso, or both)? (5 points)
Code quality (0–25 points)
- Readability and naming? (10 points)
- No obvious bugs or tech debt? (10 points)
- Gradle/build configuration sensible? (5 points)
Total: 100 points
Pass threshold: 65–70
What scores actually mean
85+: Strong hire
The candidate solved the problem cleanly, thought about edge cases, and wrote code you wouldn't hesitate to merge. In a walk-through, they explain their reasoning clearly. They might be missing optimization thinking or missing some platform knowledge, but they're fundamentally sound.
Action: Move to next round confidently.
70–84: Adequate, with gaps
They solved the problem. Code works. But there are rough edges: maybe a potential memory leak, maybe the state management is tangled, maybe error handling is incomplete. In the walk-through, they can explain most of their code but fumble on edge cases.
Action: Depends on role level. For junior roles, this is fine. For senior roles, this is a pass but a soft one. Spend the walk-through probing the gaps to understand growth trajectory.
60–69: Passing technically, concerning strategically
The code works but it's clear they struggled. Maybe they needed documentation for platform APIs, maybe their testing is weak, maybe the architecture is fragile. They passed because the requirements were met, not because the solution is good.
Action: Interview them deeply. The score says "technically capable." But can they actually do the job? Can they grow? Will they be a sink for code review time?
Below 60: Not ready
Code is incomplete, doesn't compile, or demonstrates fundamental misunderstanding of the platform.
Action: Likely pass unless they show exceptional growth potential in the conversation.
The walk-through is where scores become decisions
A 72 score by itself is ambiguous. In the walk-through, you find out why:
"Walk me through how you saved the user's preference to disk. What's the flow from user interaction to persistence?"
Strong answer (72 → 80+): "I use UserDefaults for simple data. For complex data, I use Codable and JSON serialization to a file. I check for errors on read (file might not exist) and write (disk might be full). I tested this by mocking the file system."
This shows they understand the domain. The 72 was conservative grading; they're actually strong.
Weak answer (72 → 55): "Uh, I'm not sure. Maybe I saved it somewhere? I didn't think much about errors."
This shows they guessed their way through. They're below threshold.
Common interpretation mistakes
Mistake 1: Confusing "didn't finish" with "doesn't know"
If the assessment is 90 minutes and they ran out of time, that's a signal about time management and scope estimation, not competence. Someone who writes less code but thinks about it is better than someone who writes fast and poorly.
Adjust your interpretation:
- Did they finish the core requirements? (Yes: not a major red flag)
- Did they finish and then go for stretch goals? (Yes: strong signal)
- Did they finish but it's sloppy? (Bad signal)
Mistake 2: Overweighting a single aspect
If they nailed the feature but didn't write tests, is that a deal-breaker? Depends on the role and team. A startup might accept no tests if the engineer is strong on features. A mature platform team might eliminate them for weak testing culture.
Decide your weighting before you grade.
Mistake 3: Grading the wrong thing for the platform
iOS: If they built the feature but used a deprecated UIView instead of SwiftUI, that's not a fail. Decide what matters for your team. If you're maintaining legacy code, they need to know both.
Android: If they use Java instead of Kotlin, same question. Backwards compatibility matters only if it matters for your work.
Mistake 4: Assuming a weak score means weak engineer
Sometimes strong engineers have a bad day. They misunderstood the requirements. They spent 30 minutes on a detail that didn't matter. They got stressed and wrote sloppy code.
The assessment is one signal. The walk-through and reference calls are others. Use the full picture.
What to do with borderline scores
65–70 range
Schedule a targeted second assessment: "Here's a similar problem. This time, focus on architecture." See if they score higher (testing anxiety, not competence) or lower (actually struggling).
Or move to a live coding round. Sometimes people code better in real time with feedback than alone.
60–64 range
Before rejecting, ask: What specifically is the gap?
- Missing platform knowledge? (Fixable, not a blocker for right culture)
- Weak problem-solving? (Hard to fix)
- Good thinking, bad execution? (Can improve)
- Wrong role fit? (Different assessment might show strength)
If the gap is learnable, consider hiring and investing in onboarding. If it's fundamental, pass.
Building assessment validity over time
Once you've hired a few people using an assessment, check: Did high scorers succeed? Did low scorers struggle?
- If 75+ scorers all succeeded and 65-score people all failed, your threshold is right.
- If some 70-scorers are now top performers, maybe you're grading too hard.
- If 80-scorers are underperforming, maybe the assessment isn't predictive.
Track this over time. Adjust rubrics based on what you learn.
Red flags in assessment interpretation
"The code is ugly but it works"
The code will be maintained. Ugliness compounds over time.
"They don't know async-await"
If the role requires async code, this is a problem. If not, it's just missing knowledge.
"They solved it a different way than I would"
Different doesn't equal wrong. Evaluate against the rubric, not against your preferences.
"They used a library instead of building it from scratch"
Smart engineers use libraries. Penalizing that is backwards.
Bringing scores to the hiring meeting
Don't just say "72/100." Say:
"They scored 72/100. Specifically: strong on correctness (28/30), weaker on architecture (18/25). In the walk-through, they demonstrated solid understanding of lifecycle and state management. The gap is in thinking about testability and error edge cases. For a mid-level role, this is acceptable. For senior, they'd need to show growth."
This is a hiring decision, not a score reading.
How to build consistent grading across teams
- Use the same rubric for all candidates at a level
- Grade on the rubric, not gut feeling
- Have two people grade independently, discuss gaps
- Document your pass/fail reasoning
- Adjust the rubric after hiring cycles based on outcome
When you hire someone and they succeed, revisit their assessment. What score did they get? Validate that your rubric worked.
This is how to assess mobile developers at scale without burning out your team or making bad hires.