The Developer Who Got Recruited Through Her Blog
Most people spend years applying to Apple. Natalia Panferova didn't apply at all. The SwiftUI team found her blog - a technical diary she kept at lostmoa.com - and sent her a message: "We found your blog. You seem passionate about the framework. Would you like to come work here?"
She said yes. In November 2020, she joined Apple as a SwiftUI Frameworks Engineer and spent nearly two years building the low-level machinery that millions of iOS developers use every day: AttributedString (Swift's type-safe attributed string API), Markdown support in Text views (so a `Text` view can render clickable links directly), and the modal sheet detents system that lets apps pull up half-sheets, size-adjustable panels, and context-aware presentations.
"We found your blog. You seem passionate about the framework. Would you like to come work here?" - Apple's SwiftUI team, reaching out to recruit Natalia in 2020
In April 2022, she left Apple. Not because anything went wrong - because something better was possible. She and her partner Matt co-founded Nil Coalescing, a technical education company named after Swift's `??` operator. The premise: too many iOS developers copy-paste SwiftUI code without understanding the mental model behind it. Natalia had that model. She'd helped build the framework. Now she was going to teach it.
Today she runs Nil Coalescing from Alexandra, a small town in New Zealand's Central Otago wine country, with Matt, their two dogs, and a Studio Display. Four books. A blog with detailed, practitioner-grade posts. A monthly newsletter. Conference keynotes. She is one of the most credible voices in the Swift community - not because of credentials, but because she wrote the source code.
The career path looks clean in retrospect. It wasn't. She started with Java and Python. Briefly considered computational linguistics. Pivoted to web development, worked at Paw (a macOS HTTP client, now RapidAPI) writing JavaScript extensions and React frontend. Did a coding bootcamp in Portugal in Ruby and Rails. Found Ruby "too dynamic and free form." Discovered Swift the year Apple released it and felt, in her words, "that's perfect for me." Spent years building iOS apps across Europe and New Zealand. Built her own apps - Cleora, a native HTTP and WebSocket client for iPad and Mac - just before Apple came calling.
The throughline in all of it: she gravitates toward precision. Type safety over flexibility. Understanding over imitation. Explanation over authority.
Apple found her through her blog. She had not applied for the job.
She keeps an iPhone 12 just for beta testing. Her real phone is Cosmic Orange.
Her business is named after the Swift ?? operator. Yes, on purpose.
What "Built the Framework" Actually Means
When developers talk about SwiftUI, they talk in abstractions. Views, state, bindings. But every abstraction has an implementation. Someone wrote `AttributedString`. Someone designed the API for `sheet(isPresented:)` with a detent parameter. Someone figured out how Markdown should render inside a `Text` view, and what accessibility properties it should carry by default.
That someone was often Natalia.
struct ContentView: View {
@State private var isPresented = false
var body: some View {
Button("Show Sheet") { isPresented = true }
.sheet(isPresented: $isPresented) {
Text("Half-sheet, sized by Natalia's API")
.presentationDetents([.medium, .large])
}
}
}
The sheet detents system, introduced in iOS 16, let apps do something previously impossible without custom UIKit work: present a half-sheet that users can drag to full screen. It sounds simple. The API design is deceptively clean. That cleanliness is the hard part - making a complex behavior feel obvious to call.
Natalia also co-authored the Swift.org Blog post on WWDC22's Swift language announcements in July 2022, one of the few times a framework engineer's name appeared on official Apple developer communications. Most of her work exists quietly inside Xcode, running on every iPhone and iPad on the planet.
The Company Named After an Operator
Nil Coalescing, the company, is named after `??` - Swift's nil-coalescing operator, which says: if this value exists, use it; if not, here's a fallback. It's a fitting name for a business built on the idea that most SwiftUI education fails developers the same way bad code fails users: no fallback when things get confusing.
The business runs on books, a blog, and a monthly newsletter. No venture capital. No headcount. Two people - Natalia and Matt - working from New Zealand wine country, publishing work that holds up over time because it's grounded in how the framework actually operates, not just what it does.
The blog has been the anchor. Posts like "Mysteries of SwiftUI Text View" (shortlisted for a Swift Community Award in 2022), detailed breakdowns of sheet presentations, navigation transitions, accessibility labels from localization files. Not tutorials. More like guided archaeology - here is the thing, here is why it is the shape it is, here is what happens when you push on it.
The newsletter - Nilcoalescing - launched January 30, 2025. Monthly cadence. Technical updates, new posts, exclusive discounts on books. It's the signal channel: follow it and you know when something real has shipped.
Monthly updates from the Nil Coalescing team. Technical learnings, new posts, exclusive book discounts. Launched January 30, 2025.
SubscribeFour Books, One Consistent Argument: Understand, Don't Memorize
Each book ships with lifetime free updates and EPUB/PDF formats. They are not tutorials. They are explanations - built by someone who worked inside the system she's describing.
Multiple approaches to gradually adopting SwiftUI in UIKit projects. Navigates the common pitfalls of hybrid codebases - the kind of book that saves months of painful discovery. Essential for teams with legacy UIKit apps.
$40 - Lifetime Updates100+ advanced Swift tips across 10 chapters for experienced developers. The April 2025 update added Swift 6.0 and 6.1 techniques: noncopyable types, typed throws, AsyncStream, TaskGroup, metatype key paths. Not for beginners.
$35 - Lifetime UpdatesCore SwiftUI concepts and APIs - not a reference guide, a mental model transfer. Why SwiftUI views aren't persistent objects. Why state management requires property wrappers. Why the framework makes the choices it does. Updated for iOS 26 and Liquid Glass design.
$35 - Lifetime UpdatesA field guide to SwiftUI patterns and anti-patterns for production apps. Platform-respectful accessible interface design. Building an intuition for working with the framework rather than against it - written for the age of AI-assisted coding, where understanding matters more than ever.
$35 - Lifetime UpdatesAccessibility Isn't a Feature. It's a Design Constraint She Takes Seriously.
In the iOS developer world, accessibility often gets treated as an afterthought - the checkbox after the launch. For Natalia, it's threaded through the work from the start. Partly because her contributions at Apple touched accessibility directly (Markdown in Text views improved how screen readers handled rich text). Partly because she writes and teaches about it with specificity, not generality.
There's no manifesto here. The work just includes accessibility the same way it includes correctness - as a non-negotiable property of the code, not an addition to it.
From Java to SwiftUI Team. Via Portugal.
The career of someone who consistently followed what felt right over what seemed safe. Le Wagon bootcamp in Lisbon because she wanted to understand web development. A pivot away from Ruby because it felt too loose. A swing toward Swift the moment it existed. A blog because she wanted to work through ideas. An Apple job offer she didn't see coming.
Where She's Shown Up
Small Town. Big Framework. Two Dogs.
Alexandra, Central Otago sits in the middle of New Zealand's South Island, surrounded by mountains and vineyards. It's not where you'd expect to find one of the most credible voices in Swift education. It's exactly where you'd want to work if the goal is to think clearly, write well, and ship things with no noise.
Natalia and Matt run Nil Coalescing from there. Two people, the internet, and a shared conviction that software education is mostly too shallow. She walks with the dogs. She uses a Studio Display. She writes posts that take hours to read properly because they're worth the time.
She started programming thinking about computational linguistics. She writes about APIs the way a linguist would - not just what the words mean, but why they're structured the way they are, what the grammar is, where the ambiguities live.
On AI and coding: she uses ChatGPT and Gemini for brainstorming. She does not use AI for writing code. In an industry racing toward AI-assisted everything, this is a conscious choice - not fear of the tools, but a belief that deep understanding becomes more valuable when everyone else is outsourcing it. Her newest book, The SwiftUI Way, was explicitly written for "the age of AI-assisted coding."
On risk: "If it doesn't work out, it's still okay: I still learned something myself." That sentence explains every major decision in her career. The bootcamp in Portugal. The pivot to Swift. The blog no one asked her to write. The Apple job she didn't apply for. The indie business she started anyway.
The Details That Actually Matter
Links
Everything Natalia publishes lives at nilcoalescing.com. The rest is context.