This is Part II of my 2-part mini-series about hiring and interviewing for Senior Engineers. Check out Part I: The D.E.N.N.I.S. system: Résumé tips for Senior Devs
I’ve been on both sides of the interview table - from a wobbling candidate, choking through disastrous answers, to a hiring manager ruthlessly grokking hundreds of potential team-mates.
I’ve seen countless CVs and conducted 100+ interviews for senior engineers - most frequently during intense post-fundraise hiring sprees at startups. This bursty experience drove me to iterate rapidly and fine-tune my techniques to detect top-tier tech talent.
The hard thing about first-round interviews is that it’s difficult to convey or determine a deep level of technical knowledge with words in a 30-minute interview.
You yourself might have experienced the excitement of a candidate who comes across brilliantly in their first interview, then the disappointment that follows when they fall flat on their face when asked to code FizzBuzz.
In this post, I’ll talk through some of the questions (and model answers!) that I’ve found effective in identifying strong candidates.
Think of it like prompt-engineering for job applicants!
Key Principles
Technical - understand deeply how your stack works
Communication - engage in discussions about trade-offs
Influence - leverage business context to drive decision-making
1. Technical
Technical knowledge, at senior levels, has to be deeper than operating your day-to-day toolkit. Getting under the hood and figuring out how stuff works moulds you into what teachyourselfcs.com calls a Type 1 engineer.
Hiring managers are keen to find these engineers - the kind that rolls up their sleeves to methodically solve a thorny problem vs the kind that spends days copy-pasting from StackOverflow to get a mysterious bug ‘working’ through trial and error.
Essentially, you want to show you understand what’s going on beneath the high-level abstraction of a framework or language:
The mechanics and design choices behind iOS mainstays like Grand Central Dispatch and Automatic Reference Counting, and the complexity they’re abstracting away
A working knowledge of performance characteristics of different data structures to select the right one for your problem - which could lead directly to a 50x improvement in execution speed
Grasping how SwiftUI’s layout engine is rendering views in response to data changes can remove the guesswork, ease your dependence on hot reloads, and allow you to rapidly squash the many visual bugs that crop up in SwiftUI (stay tuned for an upcoming article on this topic!).
Having this under-the-hood technical knowledge means that as soon as you run into these kinds of issues, you know exactly where to start - shaving about 90% off your problem solving time. This might be where the legend of the 10x engineer stems from.
Building up technical knowledge
Cultivating this skill is simple – stay curious.
WWDC talks are great resources; since the very engineers who designed the systems are sharing their insights - some of my recent favourites are Demystifying SwiftUI and Swift Concurrency: Behind the scenes.
Model answer
Q: You mentioned in your CV that you’ve been using SwiftUI professionally for the last 3 years. Can you tell me anything about how it works internally?
A: Sure! SwiftUI’s rendering engine is built on top of Apple’s established frameworks: Core Animation and Metal, which provide hardware-accelerated animation infrastructure and low-level GPU access, respectively.
SwiftUI organises views in a tree-like hierarchy, known as a view tree. Each view in SwiftUI is immutable and lightweight, which means they can be created and destroyed very quickly, and are cheap to allocate. When data changes, the rendering engine uses a diffing algorithm to redraw only those parts of the tree where data has changed.
However, this view diffing algorithm also means that the layout and rendering process applied on redraws can get costly if the views or view models are not designed efficiently - which is why it's important to keep views and view models compact and focused, which helps SwiftUI perform more efficient redraws.
2. Communication
For senior engineers, communication skills are the second critical pillar of first-round interviews. While general communication prowess is evident in a candidate's self-promotion, exploring technical trade-offs tells the hiring manager you’re thoughtful in how you apply your technical knowledge.
For example, less skilled engineers may dogmatically know to use final class and value types in Swift. However, great engineers will understand that their performance benefits stem from static method dispatch, as opposed to table dispatch. Explaining this to other engineers applies positive leverage over your entire team.