How to Become an iOS Developer - The Ultimate Guide (2024)

In this article, we're going to go over what we believe it takes to become an iOS developer. 

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 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.

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:

1. Core skills that you must have to get a job.
2. Skills that are nice to have to set you apart from the crowd
3. Common mistakes people make when attempting to learn.
4. The many free resources available to help you learn Swift.
5. How to get in touch with the iOS development community.
6. An estimate of how long it will take to achieve your goal.
7. Getting ready to apply for your first job.

Read the whole post or skip directly to the information you’re looking for, it’s entirely up to you!

What is an iOS developer?

An iOS developer works on apps for the Apple range of phones. iOS is specifically for the iPhone and you’ll be primarily working with games and apps for that phone.

You might be involved in:

• Designing and planning apps
• Writing code and developing apps
• Performing maintenance on apps or app servers
• Identifying issues and resolving them
• Developing updates and improvements
• Working with teams across the entire app lifecycle

Even though you’re specializing in one particular product, there’s a lot involved in the average day.

Let's break the five items down into smaller chunks.

Core 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 we believe you’ll need as an iOS developer:

1. Swift programming
2. SwiftUI 
3. Networking
4. Working with data
5. Version management

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. 

It is simply a language like JavaScript or Python. It's just pure code that you use to create variables, write functions, and so on.

Swift is only a few years old and makes use of almost every cutting-edge feature available. 

This means that you can avoid all 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.

2. SwiftUI

The second core skill required is SwiftUI. It’s an Apple framework that allows us to use Swift to create apps for iOS, macOS, tvOS, and even watchOS. 

Where Swift is the programming language, SwiftUI provides the tools for developers to create apps.

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.

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.

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 was written for Apple's older language, Objective-C. As a result, it has all sorts of quirks resulting 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.

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. 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 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.

Which is where the other essential skill comes into play, working with data. 

Again, there are numerous ways to load and save data. The absolute minimum you must be able to do is convert the data you received from a server 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.

Version control

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.

Few people 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. You may also be able to 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.

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:

• UIKit 
• Core Data 
• Validation
• Testing
• Software architecture
• Multithreading

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.

UIKit

First, there's UIKit. This is Apple's older user interface framework, which has been used for app development since 2008 – 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. If you join a company that has a large, well-established app, you will almost certainly be required to write UIKit code to maintain it.

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.

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 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. 

Core Data allows you to manipulate 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 user 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 doesn’t 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.

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 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 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.

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.

Software architecture

The fourth extension skill we'd like to discuss is software architecture, which is 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.

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 if 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.

That's the way it should be.

Multithreading

The final extension skill we will discuss is multithreading. This is the practice 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, 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 run slower, and you will now have to deal with all 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 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.

Mistakes I see them all the time and know how they set people back.

There are seven major issues that people face. 

1. Remembering everything
2. Shiny object syndrome 
3. Lone wolf learning
4. Making use of beta software
5. Depending on Apple's documentation
6. Getting bogged down in Objective-C
7. 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.

Nobody remembers everything. Nobody comes close to remembering everything.

Even if you only consider the APIs published by Apple, there must be well over a hundred thousand of them. 

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, 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. 

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.

Avoid shiny object syndrome

The second most common issue is "shiny object syndrome."

This is where we find a tutorial that works and we begin making progress. But after a week or two, we notice another tutorial series that we want to follow and jump ship to that instead. 

The issue here is that many aspects of learning 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 delaying 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 don’t need any help.

This method works for a very small number of people, typically those with extensive experience with other programming languages or platforms. 

However, for most people, learning in this manner is a terrible experience.

Every mistake or misunderstanding takes five times as long to notice and then 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. 

You’ll discover a fantastic community of learners who will support and encourage you. 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, it's not usually 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, "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 like trying to learn a human language by reading a dictionary.

The docs are 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. 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. 

The most common target is JavaScript. You'll also see people take aim at Python, Java, Ruby, Go, and other languages, and for what?

It's not a race – those languages don't have to lose for Swift to win. In fact, Swift and SwiftUI are frequently inspired by other languages and frameworks.

Whenever new language features are considered, the community looks at similar implementations in Rust, Python, Haskell, and other languages, and SwiftUI is heavily influenced by the JavaScript React framework.

iOS development resources and courses

Now for the part that most people are interested in. What are resources should you 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:

1. Some people believe that the higher the price of a Swift course, the better it must be.
2. 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 like 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.

Tutorials

To begin, Apple has two major resources that can assist you. The first is its Teaching Code website.

It 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.

YouTube and other sites

There are some excellent YouTube videos that walk you through the fundamentals of SwiftUI.

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.

App-based education

If you prefer to learn through apps, I recommend one that’s completely free. Apple's Swift Playgrounds app.

It 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.

Finding solutions

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/X, 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 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.

Antoine van der Lee runs an iOS development website at https://www.avanderlee.com, but he also shares some great links to useful resources he finds on GitHub, newsletters, and more.

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.

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. 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 and one we want to address right now.

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’s 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! 

Every time you try something, make a mistake, or take a wrong turn, you learn something along the way. 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. If you have 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.

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 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 hireable in just 3 months, which is incredible.

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."

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.

Getting ready to apply

Finally, 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 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 them are particularly long, but they are all designed to provide you with the skills you need to perform well in an interview.

Where now?

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.

I also covered how to prepare for your job interview.

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 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.

Good luck on your journey! 

About the Author

Author: David AttardWebsite: https://www.linkedin.com/in/dattard/Email: david@collectiveray.com

David has been working in or around the online and digital industry for the last 21 years. He has vast experience in the software and web design industries using WordPress, Joomla and niches surrounding them. He has worked with software development agencies, international software companies, local marketing agencies and now is Head of Marketing Operations at Aphex Media - an SEO agency. As a digital consultant, his focus is on helping businesses get a competitive advantage using a combination of their website and digital platforms available today. His blend of technology expertise combined with a strong business acumen brings a competitive edge to his writings.