What mobile development is
Mobile development is building apps for phones and tablets: the apps you install from the App Store or Google Play.
There are two main platforms: iOS (iPhones and iPads, made by Apple) and Android (phones from Samsung, Tecno, Google and many others). You can build an app separately for each, using each platform’s own language, or build one app that runs on both, using tools like Flutter or React Native.
Building for phones is different from building websites, because you’re not in control. The phone can pause your app the moment the user switches away, close it completely to free memory, refuse to let it run in the background, and deny it the camera or location. Apple and Google also review every app and can refuse to publish it. Most of this course is about writing apps that cope with all of that.
What you’ll be able to do
By the end you will be able to:
- explain what makes phones different from web and desktop, and the differences between iOS and Android;
- write an app that survives being paused or closed by the phone without losing the user’s work;
- build screens with modern tools (SwiftUI, Jetpack Compose, Flutter or React Native) and move between them;
- make an app that keeps working without internet, and syncs when the connection comes back;
- ask for permissions politely, keep the battery healthy, and keep data safe on the device;
- release an app to the stores and roll out updates safely;
- choose between building for each platform separately or for both at once.
Where to start
Before you start: basic programming (Programming Fundamentals). Some frontend helps, because modern mobile screens are built the same way.
The notes work whichever platform you choose. Start with 01–03: they’re the limits phones put on you, and everything after is about working within them. Read 14 right after 02 if you still need to choose between building for each platform separately or for both at once.
- What Makes Mobile Different: the six limits of building for phones, what changes compared with the web, and what’s actually nicer.
- The Two Platforms: iOS and Android compared on what affects your work, how much they share, and where to start.
- The App Lifecycle: the note that shapes the most code. The phone decides when your app runs, pauses and dies, and how to make sure the user loses nothing.
- Declarative UI: building screens by describing what they should look like for the current data. SwiftUI, Compose and React all work this way.
- State and Architecture: how to organise an app’s code and data, the way both platforms now recommend.
- Navigation: moving between screens, the back button, and opening the right screen from a link.
- Data and Offline-First: the most important design decision: keep the data on the phone first, so the app works without internet, then sync it.
- Networking on Mobile: why phone networks are slow and costly for the battery, and designing for apps that stay in use for years.
- Permissions and Privacy: asking for the camera, location and so on in a way users accept, and the privacy rules the stores enforce.
- Background Work and Push: what your app can do when it’s not on screen (much less than you’d think), and push notifications.
- Performance and Battery: starting quickly, scrolling smoothly, and where the battery actually goes.
- Security on the Device: the app runs on hardware the user, or an attacker, controls. Nothing in your app is secret, so the server must check everything.
- Release and Distribution: getting through store review, releasing to a few users first, and two switches to build in before you need them.
- Native vs Cross-Platform: choosing between separate apps for each platform and one app for both, based on your team and your app.
Frameworks: building for a specific platform
- iOS: Swift and SwiftUI.
- Android: Kotlin and Jetpack Compose.
- Flutter: Dart, one app for both platforms, drawn by Flutter itself.
- React Native: TypeScript, one app for both platforms, using real native components. Start with Expo.
The languages have their own courses: Swift, Kotlin and Dart. For React Native’s TypeScript, see React.
Practice
- Projects: hands-on tasks, each with a clear “done when”. Start with “survive process death”, an afternoon that teaches the core idea. The one that matters most is publishing a small app to a store, because that process can’t be practised any other way.
- Mobile interview prep: the questions about the app lifecycle are the ones that separate people who’ve shipped apps from people who’ve followed tutorials.
Key ideas to remember
- The phone can close your app at any moment. Save what matters so the user never loses work. → 03
- Keep the data on the phone first, and treat the internet as something that comes and goes. → 07
- Nothing inside your app is secret. Anyone can take it apart; the server must check everything. → 12
- Build a way to switch features off remotely before you need it. Once an app is released, users update slowly. → 13
Related
- Frontend: the closest discipline; note 04 is largely shared with it.
- Backend: the server your app talks to.
- Desktop: the same “one app or several?” question, for computers.
- Operating Systems: what “the phone closes your app” means underneath.
About this course
- Size: 14 notes, plus guides for four frameworks and interview prep. Written in August 2026, when the vault had courses for web, desktop and games but nothing for phones.
- Where it came from: reference sources. Nothing here has yet been published to a store by its author; the projects exist to change that.
Software engineering
Infrastructure & security
Computer science
Hardware & engineering