In this article, we're going to go over what we believe it takes to become an iOS developer in the next few months.
We're aiming this guide squarely at two groups of people, absolute Swift beginners (Swift is the language that is used to code iOS apps) – people who have never built anything for iOS before – and so-called false beginners – people who have tried to learn Swift before but never really achieved their goal of getting a full-time job.
Regardless of your current level, the goal here is the same. To put you in a position to apply for a junior iOS developer role at a company.
We'll look at the skills you should be learning, the courses you can take, how to get connected to the community, common mistakes people make, and more.
Best of all, everything we'll discuss will be completely free, so you won't have to pay anything to follow along.
Seriously, far too many people believe that spending a lot of money will put them on the fast track to their dream job, when the most important factors are determination and willpower.
This article is divided into seven sections:
- Core skills that you must have in order to get a job.
- Extension skills that are nice to have – the ones that will set you apart from the crowd if you put in the effort to learn them
- Common mistakes people make when attempting to learn.
- The many free resources available to help you learn Swift.
- How to get in touch with the iOS development community.
- An estimate of how long it will take to achieve your goal.
- Getting ready to apply for your first job.
Fundamental skills required to become an iOS developer
What is the absolute bare minimum of skills required to land a job in iOS development?
There are five essential skills in total:
- Swift programming
- Working with data
- Version management
That list is intentionally kept short for a variety of reasons:
The more you learn, the more you realise there is to learn, so it's easy to spend so much time studying and practising that you lose sight of the main goal.
You want to work as an iOS developer, not just sit around learning new things!
It's almost certain that you'll be joining a team that already has an app they want you to help develop, so unless you get extremely lucky, they'll need to teach you a whole bunch of stuff regardless.
If you try to cram a whole bunch of extra topics in beforehand, you're probably wasting your time.
Two of those five things are huge and complicated, and you could spend months just trying to wrap your head around them without venturing anywhere else.
Most importantly, if you get those five things right, you can create a wide variety of apps. Sure, your code won't be perfect, but that's okay because the only way to write great code is to first write a lot of bad code.
Let's break the five items down into smaller chunks.
1. Learning Swift
Swift is first on the list. This is Apple's core programming language. It has no concept of displaying information on an iPhone's screen or downloading data from the internet.
Swift is only a few years old, so it makes use of almost every cutting-edge language feature available.
On the one hand, this means that you can avoid all of the old behaviours that are common in older languages like C++ and Java. It also means that it has a slew of advanced features that you can take advantage of.
And that's fine. Many parts of Swift are relatively simple, while others will take you longer to fully grasp, experience and practice makes perfect.
The second core skill required is SwiftUI, which is an Apple framework that allows us to use Swift to create apps for iOS, macOS, tvOS, and even watchOS.
So, while Swift is the programming language, SwiftUI provides the tools for developers to create apps, such as how to display images, text, buttons, text boxes, data tables, and more.
To be clear, SwiftUI isn't a replacement for Swift – it's a framework built on top of Swift that allows us to create apps. You'll need to know both Swift and SwiftUI to succeed.
If you thought Swift was new, you haven't seen nothing yet!
SwiftUI is a fairly young framework, it first appeared in 2014, and it was developed to replace the archaic Objective C.
Despite its young age, the iOS community has embraced it wholeheartedly because it's so easy to use.
Apple also has an older framework for building iOS apps called UIKit. If you ask a bunch of people whether you should learn SwiftUI or UIKit first, you'll get a variety of answers.
We think you should learn SwiftUI and here is the reasoning why you should prioritise SwiftUI as a core skill.
SwiftUI is significantly easier than UIKit, and – it takes perhaps a quarter of the code to achieve the same results as UIKit, and there are fewer things to learn along the way.
This means you gain a lot of momentum because you can build things faster, see results quicker, and iterate on those results with more agility, which is extremely motivating while learning.
Created for Swift
SwiftUI was created for Swift, using language features to assist in avoiding problems and achieving maximum performance.
For example, if you change some data on one screen of an app, SwiftUI will automatically ensure that the new data is updated anywhere else in your app that uses it – you don't have to write code to keep it all in sync yourself, which is typically quite complex.
UIKit, on the other hand, was written for Apple's older language, Objective-C, and as a result has all sorts of quirks that resulted from its age.
SwiftUI is compatible with all of Apple's platforms, so you can use what you learned on iOS to create a macOS or watchOS app with nearly identical code.
Of course, features such as the Digital Crown, are exclusive to a single device, the Apple Watch, but the vast majority of what you learn will work on any device.
But, most importantly, SwiftUI is the direction in which things are heading.
If you were applying for a job a few years back, you'd probably need to know UIKit, but the fact that you're reading this means you're much further along in the process.
While, UIKit used to be more popular, SwiftUI is now the dominant UI framework.
The world's largest companies, including Apple themselves are now moving forward with SwiftUI.
When Apple recently launched widgets in iOS 14, they made it a requirement that you use SwiftUI.
Networking and data manipulation
The third and fourth skills we mentioned were networking and data manipulation. When compared to Swift and SwiftUI, these are quite simple, or at least simple at the level required to get a junior iOS developer job.
Networking is the practice of retrieving data from the internet or sending data from a local device to a remote server. On a mobile app, this is of course a fundamental skill.
There are numerous methods for accomplishing this, but the most important thing to understand is how to retrieve JSON from a server.
And this is where the other essential skill comes into play, working with data.
Again, there are numerous ways to load and save data, but the absolute minimum you must be able to do is convert the data you received from a server using your network code into information that your app can display.
So, the third and fourth core skills are inextricably linked. Fetch some data from a server, then convert it into information that can be displayed in your app. Some developers joke that writing this type of code is half the job of an iOS developer, and it's certainly true that we rely heavily on it.
The final skill isn't coding at all, its version control, such as Git. Again, you don't need much here, but it's important that you're able to publish your code somewhere public, such as GitHub, so recruiters can see your work.
Nobody in the world truly understands how Git works, but that's okay – you just need to know enough of the basics to store your data safely and collaborate with others.
So, when those five are added together, there are two massive ones – Swift and SwiftUI – as well as three minor but important ones.
If you can just focus on those five things without getting distracted, you'll be well on your way to your first iOS developer job.
That's it: those are the five essential skills I believe you need to be an iOS developer.
There are thousands of people who only have those skills and can build and ship fantastic apps on the App Store.
What comes after the fundamentals?
Once you've mastered the five core skills, you'll be able to ship your own apps and work as an indie developer, as well as apply for junior iOS development positions and work for a company if that's what you want to do.
There are no other special qualifications required – just nail those core skills and you'll be fine.
However, if you've mastered those skills and want to advance, there are five more skills we would recommend you learn. These are the skills that will propel you from a good to a fantastic position – you'll become even more employable, and the range of apps you'll be able to build will expand even further.
The abilities are as follows:
- Core Data
- Software architecture
As before, we'd like to go over each of these in greater detail so you understand why we think they're important – and why we think of them as extension skills rather than core skills.
First, there's UIKit. This is Apple's older user interface framework, which has been used for app development since 2008 – it's 14 years old as I write this, which is old in software terms. But that doesn't mean UIKit is bad. In fact, as you get used to how it works, you'll be surprised at how elegant it can be.
There are numerous reasons why UIKit is worthwhile to learn, including:
Hundreds of thousands of apps have already been written in UIKit, so if you join a company that has a large, well-established app, you will almost certainly be required to write UIKit code to maintain that app.
UIKit is far more powerful than SwiftUI – there are many things you can do in UIKit that are not currently possible in SwiftUI.
Using Auto Layout technology, you can create extremely precise layouts.
If you run into issues with your code, UIKit has more solutions than SwiftUI simply because it has been around for a much longer time.
All of this makes UIKit sound fantastic, so why did I make it an extension skill rather than a core skill?
Because UIKit has issues as well:
Almost everything is more difficult to do in UIKit than in SwiftUI, with some tasks requiring a hundred times, if not more, code.
SwiftUI was designed specifically for modern iOS development, so it does a lot of the heavy lifting for you.
Because UIKit was not written in Swift, it has many features that SwiftUI does not have – many implicitly unwrapped optionals, marking code with a special @objc attribute to make it available to UIKit's Objective-C underbelly, and the need to use protocols and delegates to display simple data.
Nothing about Auto Layout is "automatic" – in fact, if you ever try to build a complex layout, you may have nightmares about Auto Layout. It's extremely clever, but it's also extremely difficult in places.
And this is why we consider UIKit to be an extension skill: it takes significantly more time and effort to learn than SwiftUI, which means it requires a lot more determination – you have to really want to learn it, or else you'll get confused, bored, angry, or potentially all three.
Sure, SwiftUI doesn't have all of the features of UIKit, but it allows you to make quick progress and gain momentum before moving on to UIKit.
Managing Core Data
Core Data, Apple's framework for working with application data, is the second extension skill I mentioned.
We mentioned networking and working with data in the core skills section, and it's true. With those skills in place, you can fetch whatever you want from a server and display it in your app.
Core Data takes it a step further by allowing you to manipulate that data once you've obtained it, such as searching for specific values, sorting the results, and more, all very efficiently.
It can also easily connect to iCloud, ensuring that your users' data is synchronised across all of their devices.
Core Data has a slew of drawbacks, the most serious of which is that it isn't always pleasant to work with. Core Data is nearly as old as UIKit, and while it worked well in Objective-C, it does not feel as natural in Swift.
It integrates well with SwiftUI, which makes it feel less strange, but it's still a surprisingly complex topic.
Like UIKit, Core Data is extremely popular – hundreds of thousands of apps have been built with it, and it is used in many large and small businesses.
Core Data, like UIKit, is extremely powerful, and while you could recreate the most important parts of it in your own code, why would you?
Testing your code
The third skill on my list of extensions is testing. Writing special code to ensure that your main app code works as expected.
Tests allow us to ensure that our code works correctly, and more importantly, that it continues to work correctly even after we've made significant changes to it.
For example, if you change 500 lines of code to implement a new feature and all of your tests pass, you're good to go.
As a result, testing is critical and will assist you in writing higher-quality software.
So, why is it considered an extension skill rather than a core skill?
There are three reasons for this:
The iOS community as a whole is terrible at testing, for whatever historical reasons. Many large apps have no tests at all, and tragically a number of senior iOS developers are almost proud they never write tests.
When you consider all of the amazing things you can create with Apple's tools and frameworks, writing tests doesn't seem like much fun in comparison.
When applying for a job, knowing Swift and Apple's major frameworks will always be more useful than knowing how to write tests.
Companies would prefer that you know how to use SwiftUI, UIKit, or one of the other big hitters, because testing is a much smaller topic – there aren't nearly as many things to learn.
So, testing is important, testing matters, and if you want to be a great overall developer you need to learn how to write great tests. But only after you've mastered the fundamentals of app development – after you've had some success, felt the rush of having your app live on the App Store, and mastered testing.
The fourth extension skill we'd like to discuss is software architecture, which is really about how we write code.
You're going to write some terrible code when you're first starting out.
That's okay because that's how you learn. You don't start good – you get good by being bad for a long time and learning better ways of doing things with experience and exposure.
The point is that you stick with your bad code until you figure out how to do better. That's where software architecture comes in. Looking at tried-and-true techniques for structuring your code to make it easier to read, use, modify, and maintain in the long run.
These techniques sometimes rely on the way Swift works – language features that can be used to write better code.
However, there are numerous other techniques that work in any programming language and are commonly referred to as design patterns.
One important aspect of this skill that you should begin to learn is how to break up your code.
For example, if you're creating a single screen in your app, it could include a login button, an image gallery, and a list of friends.
However, you should ideally separate each of those parts – a login button component, an image gallery component, and a friends list component – so that you can reuse any of those components in other parts of your app.
Software architecture is far more subjective than the other skills we've discussed thus far. For the others, such as SwiftUI, you can reason, "Well, I know how to do X, Y, and Z, so I'm confident I'm a good SwiftUI developer."
Software architecture is a very broad topic, and there is often no obvious "right" way to solve a problem, so the best benchmark for it is this: do you look back on your code from six months ago, a year ago and so on.
Writing bad code is acceptable as long as it gets you closer to writing better code.
You'll certainly scratch at your head in places when you look back on code you wrote five years ago, because you'll know more now than you did then – and that's the way it should be.
The final extension skill we will discuss is multithreading, which is the practise of making your code do more than one thing at a time.
Multithreading can be a real pain because it's difficult for our brains to understand. When your code does one thing at a time, we can think it through linearly, but when two or three things happen at the same time, potentially overlapping, it can really mess with your thinking.
So, while multithreading is a great skill to have as an extension skill, you should be cautious. Your goal should be to understand just enough of the concepts and code to make it work well without going too far.
To be honest, many developers believe that multithreading will instantly make their code run three or four times faster.
While this is true in some cases, in many other cases, your code will actually run slower, and you will now have to deal with all of the additional code complexity.
“My specific recommendation is that you avoid writing async/concurrent code as much as possible. This may seem strange in 2018, but the cost in complexity and performance is high.
So, learn a little bit about how multithreading works in Swift to demonstrate that you understand the concepts and implementation, but don't go overboard!”
David Smith - Apple SwiftUI team
Common mistakes new iOS developers make
At this point, we've listed all of the core and extension skills you'll need to work as a full-time iOS developer.
We also want to discuss some of the most common mistakes people make while learning, because I see them all the time and know how they set people back.
There are seven major issues that people face.
- Remembering everything
- shiny object syndrome
- Lone wolf learning
- Making use of beta software
- Depending on Apple's documentation
- Getting bogged down in Objective-C
- Aiming at other languages
Let's go over each of them one by one.
Stop attempting to remember everything
The first, and by far the most common, issue people encounter is trying to memorise everything – reading through a tutorial and believing they must remember everything in it by heart.
Nobody remembers everything. Nobody comes close to remembering everything. Even if you only consider the APIs published by Apple, which are the pieces of code we can use to build our apps, there must be well over a hundred thousand available.
Even if you limit it to the core components of app development, you're still looking at several hundred – all working in a very precise way that requires a lot of learning to use.
Instead, you learn how to do something new and then promptly forget how to do it again.
So, you look it up, use it again, and then promptly forget about it. So, you look it up a third time and use it, and this time you mostly forget it – some parts stay with you.
This cycle continues indefinitely, with you having to refer to a tutorial or some other reference guide each time, until the fundamentals are ingrained in your mind to the point where you can do it without consulting anyone else.
If you didn't already know, forgetting is an important part of learning.
Every time you forget something and relearn it, it sinks deeper and more thoroughly into your brain. When you relearn something, your brain makes new connections with other things you've learned, which helps you understand more about the context of what you're attempting to do.
And each time you relearn, you're signalling to your brain that this particular topic is important enough to store in its long-term memory.
But if you set out to memorise everything, you're going to struggle.
Instead, don't be concerned about forgetting things. Knowing where to look them up is far more important than memorising specific Swift code to accomplish something.
When you forget something and have to relearn it, consider it a good thing – that information will sink in deeper the second, third, and tenth time you learn it, so you're helping your brain.
Avoid shiny object syndrome
The second most common issue is "shiny object syndrome," in which they find a tutorial series that works well for them and begin making progress, but after a week or two, they notice another tutorial series that they want to follow and jump ship to that instead.
The issue here is that many aspects of learning anything are uninteresting. That isn't necessarily the fault of the teacher.
It's just a fact of learning to code – some things give you great results with little effort, while others take a lot more time to understand, don't produce fancy results, or are only one part of a larger concept.
When you hit these steep learning curves, shiny object syndrome kicks in – with so many free tutorials available, you can jump ship to any one of them and restart, and you'll be back in the shallow end of the pool, covering easier parts you've already learned.
But, unless the original course chose an unusual topic to cover, you're probably going to have to learn it eventually, and you're just postponing the inevitable.
Please be aware of shiny object syndrome- when you encounter a problem, try asking someone else for assistance and persevering rather than switching.
Don't go it alone
Speaking of asking someone else, the third issue we see people run into is when they go all lone wolf with their learning – they believe they are fully capable of learning to build iOS apps using Swift all by themselves and do not require the assistance of others.
This method works for a very small number of people, typically those with extensive experience with other programming languages or platforms.
However, for the vast majority of people, learning in this manner is a terrible experience – every mistake or misunderstanding takes five times as long to resolve, it's extremely easy to lose motivation, and you're missing out on a lot of inspiration from watching others succeed.
If you're a natural "lone wolf" learner, we urge you to change your ways.
Share what you're learning, connect with others who are learning, and develop the habit of asking questions.
Not only will you discover a fantastic community of learners who will support and encourage you, but you will also be inspired by their work and, in turn, inspire them with yours. It's completely transformative.
Don’t use beta versions
The fourth major issue is when people insist on using beta versions of Apple's development tools.
Every year, Apple releases a new iOS, a new macOS, and other products, always delivering exciting new things for us to try. It's natural for people to want to learn the latest and greatest, especially if they know Swift has a long history of change.
However, when people try to learn with beta software, they run into a number of issues:
Because tutorials haven't been updated for the beta version, following their instructions won't always be possible or will fail.
Bugs are common in betas, especially those released for major iOS updates.
Apple's beta frameworks take time to stabilise, which means that code that worked in beta 1 may not work in beta 3.
So, while it's exciting to learn new things, and you may believe you're getting ahead of the game with new features, trust me: it's not worth it.
Always use the most recent public releases of Apple's developer tools until you're comfortable with them.
Relying on official documentation
The fifth major issue that people face when attempting to learn is relying on Apple's documentation.
Apple's developer publications team works hard to document as much as possible from the company's vast array of frameworks, but their main job is to write reference material – things you read when you're trying to use a specific piece of their tools – rather than creating a structured course to help you learn to build iOS apps.
We've lost count of the number of times people have asked me, "How can I learn Swift?" only to be told, "Read Apple's Swift reference guide."
This approach does work for some people.
However, for most people, it's similar to trying to learn a human language by reading a dictionary. It's intended to cover everything in the language rather than teach you the most important parts and how to apply them.
So, if you have extensive experience with other languages, reading Apple's reference guides may be useful, but if you're just starting out, you might want to revisit them after a few months.
Getting bogged down in Objective-C
The sixth major issue that people face is attempting to learn Objective-C. This was Apple's primary development language prior to the introduction of Swift, and while there are remnants in some old codebases, the vast majority of existing code is now Swift, and almost all new code is also Swift.
Some people spend years writing Objective-C before Swift and really grow to love it, but it has an extremely steep learning curve and lacks most of Swift's important features.
When Apple first announced the iPhone SDK many people were horrified by Objective-C because it was unlike anything else that had seen so far.
Objective-C and Swift have almost nothing in common for a beginner.
Yes, they share the same Apple frameworks, but unless you plan to work at Apple – the only company in the world still producing large amounts of Objective-C – you should leave Objective-C alone and concentrate entirely on Swift.
Ignoring other languages
The final major mistake people make when learning Swift is dismissing other languages as inferior to Swift.
iOS development resources and courses
Now for the part that most people are interested in: what are the actual resources you should use to learn Swift, SwiftUI, and more – in order to achieve your goal of becoming an iOS developer?
There are many out there, and the Swift community has such a diverse group of people sharing their knowledge.
However, in this article, we're going to focus on free resources – places where you can learn to build fantastic apps without spending a dime.
This is due to two factors:
- Some people believe that the higher the price of a Swift course, the better it must be, so they end up paying exorbitant prices without receiving adequate benefit.
- Many sites, such as Udemy, rely on selling a large number of low-cost courses, confident that if you don't like one, you'll just buy another. They also have a business model similar to Steam's in that there are constant sales, encouraging people to accumulate a large number of courses to study "one day."
So, here we are only listing free resources so you don't spend a hundred dollars or more on your first course, and don't buy a dozen cheap courses thinking that will make you a developer.
To begin, Apple has two major resources that can assist you. The first is its Teaching Code website, which contains student and teacher resources for learning Swift from the ground up, all the way up to professional certifications.
Their curriculum is extensive, so it may take some time to find the best entry point for you, but once there, you'll find plenty to explore.
Second, Apple has a series of SwiftUI tutorials that walk you through the process of creating real-world apps. These, however, do not teach Swift, so you must first complete their Swift-focused curriculum.
Apple also publishes a guide specifically for the Swift programming language, but there's a good chance it won't work for you – it's intended as a reference rather than a structured tutorial, so it's quite dense reading.
What Apple's tutorials don't do is attempt to provide a structured method of learning.
YouTube and other sites
There are some excellent YouTube videos that walk you through the fundamentals of SwiftUI, such as:, in which he walks you through the process of creating a slots game from the ground up. explains five SwiftUI concepts that everyone should learn when they begin programming. that features both Swift and SwiftUI while taking audience questions.
There are other sites with high-quality Swift and SwiftUI tutorials, including BLCKBIRDS, Ray Wenderlich, Donny Wals, Antoine van der Lee, and more – we really encourage people to visit a variety of resources and find what works for them.
If you prefer to learn through apps, I recommend two that are both completely free. The first is Apple's Swift Playgrounds app, which allows you to learn Swift directly from your iPad or Mac.
There are many interactive lessons aimed at children, but there are also some more advanced lessons that will help you advance your skills.
The other app is called Unwrap, and it was created by me. Unwrap is compatible with all iPhones and iPads and allows you to learn, review, and practise Swift fundamentals through videos, tests, and other tools. It covers all of the fundamentals of Swift and complements the 100 Days of SwiftUI curriculum perfectly.
Finally, you'll need to learn how to find answers online. This could mean going to Stack Overflow, but I'm hoping not because it's not a particularly pleasant place.
Instead, ask questions on the Hacking with Swift forums, your favourite Slack group, the iOS Dev Happy Hour sessions, Twitter, and elsewhere – we are a genuinely warm, welcoming community with many people eager to assist you in reaching your goals.
Getting involved in the community
Speaking of our community, I'd like to discuss a really important topic that will help you meet people in similar positions to you, learn more effectively, and find job openings – it's a win-win situation all around.
The subject is connecting with the iOS development community. This includes knowing where to look for news and interesting ideas, where to go to meet people and share tips, and where to go to ask questions.
Who should I follow on Twitter?
Let's start with the simplest, which is to use Twitter. Twitter is a fantastic way to follow things that interest you, and there are a few people I would highly recommend in the case of iOS development.
Yes, these people tweet about their own work, but I think they're great to follow because they also tweet a lot about other people's work – they'll help you see a variety of perspectives on a particular topic, and they share all kinds of interesting ideas and things to try.
Here are 9 people we recommend you follow on Twitter:
Sean Allen spends a lot of time on YouTube making Swift and iOS development videos, but he also works really hard to spread the word about other people's work – he really does a great job of helping everyone discover something new every week.
Novall Khan works for Apple, but that doesn't stop her from posting videos on a regular basis about what she's working on, what she's learning, what she's having trouble with, and more – she's really inspiring.
Steve Troughton-Smith is well-known for his earlier work tinkering with iOS, but you should really follow him for the fantastic array of links he shares to impressive work. I like how he shares the development progress of his own apps, so you can see them grow from beginning to end.
Kaya Thomas is one of our community's most well-known indie developers, and she's been featured by Apple more times than I can count. She tweets frequently about her own work and presentations, but she also shares links to books she's reading, articles she's read, and other resources.
Majid Jabrayilov not only writes a fantastic Swift and SwiftUI blog, but he's also a tireless promoter of others – if you follow him on Twitter, you'll get idea after idea sent your way from a wide variety of sources.
Donny Wals writes a Swift blog and, more recently, books on Combine and Core Data, but he also encourages people to share what they are working on on Twitter. Even just reading that thread once a week will inspire you to try new things, so you should definitely follow Donny.
Sommer Panage works on Apple's accessibility team, so while she is somewhat limited in what she can say, she does tweet out a lot of first-rate tips from herself and others that everyone can use to build better apps.
Natascha Fadeeva writes a blog about Swift and iOS development, including articles on Core Data, interview questions, and other topics, but she also tweets about things she finds elsewhere.
Newsletters and more
Of course, Twitter isn't the only place to stay in touch with the community; there are also newsletters, Slack groups, Zoom meetups, forums, conferences, and other venues. I don't want to bore you too much, so I'll just list one of each here:
You can't go wrong with iOS Dev Weekly for newsletters. As I write this, it has just passed 500 issues, one every week, which I believe tells you everything you need to know about how important it is.
If you want to post on a web forum, https://www.hackingwithswift.com/forums is pretty good. There are many categories to choose from, and anyone, regardless of experience level, is welcome to participate. You are more than welcome to post your beginner questions here, believe me!
Every month, the iOS Dev Happy Hour is held on a Zoom group call with over 300 people, but the real fun is in the breakout rooms, where you can chat with groups of 6 to 8 people at a time. It's a lot of fun, and you'll meet new people.
Attending conferences has been difficult due to the coronavirus pandemic, but Apple's WWDC was a huge success last year, and it was accompanied by a slew of community events. A group of friends and I created a GitHub repository to help keep track of all the other events, articles, and other things that happened – take a look!
Finally, if you prefer to chat on Slack where you can get answers faster, you can join the free Hacking with Swift Slack group and join one of the Swift, SwiftUI and other channels.
How much time does it take to learn iOS?
This is a frequently asked question of mine: how long does it take to progress from knowing nothing about Swift to being able to obtain an entry-level iOS developer position?
The obvious answer is "it depends," but that would be a cop out in this case, so let me address it in a few different ways.
The golden rule is to not rush
First and foremost, you cannot take multiple courses at the same time. Remember what I said about the "shiny object syndrome"? Yes, many people believe they can take two courses at the same time, then cram for four, five, or even more hours every day and still have a high-quality understanding of the topics they covered.
To be clear, I've seen people try this so many times and it always fails. Every time – it never works, and I hear people say it's because the tutorials were bad, or because Swift was too difficult, or for literally any other reason other than trying to rush through something complex.
Learning Swift can be difficult at times, and learning to build apps requires a lot of trial and error, making mistakes, and taking wrong turns. And that's fine – it's better than fine, it's fantastic!
Because every time you try something, make a mistake, or take a wrong turn, you learn something along the way, and when you finally arrive at the solution, you'll understand it much better.
So, the TL;DR here is don't rush – take your time, don't be afraid to explore tangents that arise, don't be afraid to experiment with your projects, and don't be afraid to go back to something you previously learned and relearn it as needed.
What is your educational background?
Second, you should consider your background prior to coming to Swift. You see, learning to build apps requires a wide range of skills, and if you come to the table with a wealth of prior knowledge such as version control, data structures, algorithms, and more, you'll have a significant advantage over those who are new to computer science in general, as well as Swift and other Apple frameworks.
So, here are a few possibilities for where you might be right now:
If you have a computer science degree, you will already be familiar with many of the CS fundamentals needed to get started with Swift. Variables, arrays, loops, arrays, sets, functions, OOP, and other concepts will be useful in Swift, as will all of your work with data structures and algorithms. This could save you 4-6 months of study time depending on the subjects you studied, and it will also give you an advantage when applying for jobs at many companies.
If you don't have a CS degree but have attended a coding bootcamp, you'll have many of the fundamentals you'll need to get started with Swift. This won't give you the same advantage when applying for jobs at those companies because they often expect a degree just to check a box on their list of arbitrary requirements, but it will still save you three or four months.
If you don't have a CS degree and didn't attend a bootcamp, but you've been coding in your spare time, you'll save some time – probably two months or so, depending on the language or frameworks you were using.
What if you don't have a CS degree, haven't attended a bootcamp, and have no prior coding experience? Then I'd estimate 9 to 12 months to go from nothing to an entry-level job. Yes, that could be a full year of work on top of whatever your current full-time job is, and that's just to get your first job as an iOS developer.
Is it always the same year? No. If you have prior experience, you can cut that time down to 1 to 6 months, as I previously stated. If you take the best numbers on both sides – 9 months from nothing to an entry-level job, plus 6 months for having a CS degree – that means you could be hirable in just 3 months, which is incredible.
You may believe that finding your first job in three months is impossible, but it isn't. Heck, I met someone who was taking my 100 Days of Swift course and got a job before day 50 – they had already learned enough about app development in less than two months because they put in the effort to make every day count.
So, you don't need a CS degree or a bootcamp, but you do need to be willing to work hard.
Allow yourself some leeway
The third point I'd like to make before we move on is that "it takes as long as it takes." I love a lyric by John Lennon that goes, "Life is what happens when you're busy making other plans."
It's fantastic if you have big plans for learning and big dreams for the job you want, but sometimes you're tired, sometimes you're stressed out, sometimes your roof leaks or your dog needs to go to the vet or your kids need extra help with their homework, or whatever, and that's just life.
So, don't be too hard on yourself if you fall behind with your learning schedule, or if you find yourself missing a few days or even a few weeks, and so on – as long as you're resilient, you'll get there.
That's fantastic if you work really hard and get a job after 50 days – well done! If it takes you 500 days, that's fantastic as well, and you should be just as proud of yourself. Heck, if it takes you five years, I'm sure it's not what you wanted, but the end result is the same, and that's all that matters.
Getting ready to apply
Last but not least, if you're a little further along in your iOS learning journey and thinking about landing your first entry-level job, I'd like to point you to a massive collection of resources I put together to assist you.
I'd recommend Sean Allen's Swift interview tips videos – he has a whole playlist for them where you can work through individual discussions such as classes vs structs, functional programming, error handling, and more. None of the videos are particularly long, but they are all designed to provide you with the skills you need to perform well in an interview situation.
Okay, so I've gone over the core and extension skills you'll need, common learning mistakes, courses you can take, how to connect with the iOS community, and how to prepare for your job interview – that's a lot to cover, and I hope it's been helpful.
Furthermore, I hope I've demonstrated how much information is available for free.
Yes, the temptation to spend a hundred dollars or more on a course is strong, but relax – get moving first, find some momentum, and also find someone who teaches Swift in a way that works for you. When you're in a good place and feel ready, go ahead and spend some money if you want.
Best wishes on your journey!
Please leave a useful comment with your thoughts, then share this on your Facebook group(s) who would find this useful and let's reap the benefits together. Thank you for sharing and being nice!
Disclosure: This page may contain links to external sites for products which we love and wholeheartedly recommend. If you buy products we suggest, we may earn a referral fee. Such fees do not influence our recommendations and we do not accept payments for positive reviews.