iOS Developer Job Description Templates for Small Teams
6 templates for companies hiring iOS talent without an engineering department: standard, junior, senior, contract, maintenance, and internal app roles. Download as DOCX.
Most iOS developer job descriptions online were written by companies with an engineering organization behind them. They list a stack, a seniority band, and a set of buzzwords, and they assume a hiring manager who can read code, a recruiter who can screen, and a second iOS developer who can cover the release. If you are an owner or an operations lead hiring your first mobile developer, none of that is true for you.
The gap shows up in one specific place. An iOS role carries obligations that no other engineering hire carries: App Store review sits between your team and your users, and the accounts that let you publish are Apple assets registered to somebody. Get that second part wrong and you can lose the ability to update your own app.
At FirstHR we write hiring templates for companies without a dedicated HR department. The six below cover a standard product role, a junior, a senior or lead, a contract engagement, a maintenance owner for an app that already exists, and an internal business app. Each one includes the classification and account language the generic versions leave out.
TL;DR
An iOS developer job description should state the stack (Swift with SwiftUI or UIKit), the supported OS and device range, who owns App Store submissions, and the FLSA classification. Benchmark pay to software developers: a $135,980 national median (BLS OEWS, May 2025). Keep the Apple Developer Program account in company hands. Six templates below, downloadable as DOCX.
What an iOS Developer Actually Owns
An iOS developer owns four things, and only the first one looks like a normal engineering job. There is the code, the release path through App Store review, the Apple accounts that make publishing possible, and the privacy disclosures that have to stay accurate. A posting that describes only the code will attract people who expect only the code.
That distinction matters more at a small company than at a large one, where release engineering, legal review, and account administration all belong to other departments. Here they belong to your one hire, so say so in writing before the offer rather than discovering it during the first rejected submission.
The build
Swift, Xcode, one device family
Features written in Swift with SwiftUI or UIKit, against a device range you choose and an operating system version floor you set. Everything below that floor stops receiving fixes, which is a business decision the developer should bring to you rather than make alone.
The release
App Store review is a gate you do not control
Every public update passes through Apple review, and a rejection can hold a release for days. This is the single biggest structural difference from web work: your release date is a request, not a decision, so the posting should say who owns submissions and resubmissions.
The accounts
Program membership, certificates, listing
The Apple Developer Program account, the signing certificates, the provisioning profiles, and the App Store Connect listing are company assets. Who holds them decides whether you can ship an update the week after a developer leaves.
The disclosures
Privacy details and permissions
App Privacy details, permission prompts, and tracking disclosures have to match what the app actually does, and they change every time a feature touches new data. Someone has to own that accuracy, and by default it lands on the developer.
Write the Posting Around the Job, Not the Title
The words iOS developer cover at least four different jobs. Building a new consumer app from nothing is a product role with high ambiguity. Adding features to an existing app is a craft role with an established codebase and an established review process. Keeping an inherited app alive through annual operating system releases is a maintenance role that suits a different temperament entirely. Building an internal app for your own field staff is an operations role where the users sit down the hall. Pick the template that matches the actual work, because candidates self-select on this more than on salary.
What Belongs in an iOS Developer Posting
A good posting does four jobs: it sets expectations about the work, it filters people whose experience does not match your codebase, it protects the company legally, and it closes the candidate. Most postings do the first and skip the rest, then generate volume without fit.
The parts that set expectations
What the app is and who uses it, in two sentences
Whether this is a new build, a rewrite, or maintenance
Team size and who reviews the code
Release cadence and who submits to review
The parts that filter applicants
Swift, with SwiftUI or UIKit stated explicitly
A live App Store link required in the application
Supported OS versions and device range
Testing and crash triage expectations
The parts that protect you
FLSA classification stated on the posting
Intellectual property assignment named in the offer package
Company ownership of the Apple accounts and signing keys
Equal opportunity statement
The parts that win the hire
A real pay range, not a placeholder
Remote, hybrid, or onsite stated without ambiguity
Hardware and device budget
Who the developer works with and what they own alone
The most useful filter costs nothing: require a live App Store link in the application rather than a portfolio page. Shipped apps are publicly verifiable in a way that most engineering work is not, and asking for one removes a large share of unqualified applicants before you read a single resume. Our guide to writing a job description covers the general structure, and the hiring template library holds the rest of the engineering roles.
6 iOS Developer Job Description Templates to Download
Download all six as one file or copy them individually. Each follows the same structure: company context, position summary, key responsibilities, required qualifications, a classification and compliance note, an equal opportunity statement, and how to apply. The bracketed fields are the only parts you need to change.
Download All 6 iOS Developer Job Description Templates
Standard, junior, senior, contract, maintenance owner, and internal business app. All in one download.
iOS Developer (Standard)
Your default posting
The general product role: features in Swift, tests, releases through App Store Connect, and crash and performance ownership.
Junior / Associate
Supervised, with a review loop
For a first or second job developer working under review, with the pay test that most often makes a junior role non-exempt.
Senior / Lead
Owns architecture and the release
For the person who decides how the app is built and shipped, sets performance budgets, and mentors everyone else on the codebase.
Contract / Freelance
Scope, term, and a real handover
A scope of work rather than a job posting, with account access, code ownership, and the misclassification warning written in.
Maintenance and Release Owner
An app that already exists
For taking custody of an app nobody owns: annual compatibility work, certificate renewals, crash fixes, and a written runbook.
Internal / Business App
Your staff are the users
For an operational app on company devices, with offline handling, device management, and direct support for the people in the field.
Template 1: iOS Developer (Standard)
The default product posting: features in Swift, testing, releases through App Store Connect, and ownership of crash rates and performance. Start here and cut what does not apply.
iOS Developer Job Description (Standard)
IOS DEVELOPER JOB DESCRIPTION
Company: __ ([City, State] / Remote)
Reports to: [Engineering Manager / CTO / Head of Product / Owner]
Employment type: Full-time
FLSA status: Exempt (computer employee; see classification note)
Compensation: $_ to $_ per year
ABOUT [COMPANY NAME]
[Company Name] builds [product description] for [customer]. Our iOS app has
[number] monthly active users and ships [weekly / monthly / quarterly]. The
engineering team is [number] people, and this role owns the iPhone [and iPad]
experience end to end.
POSITION SUMMARY
The iOS Developer designs, builds, tests, and releases features in our iOS app,
takes the app through App Store review, and keeps crash rates, performance, and
supported OS versions inside agreed limits.
KEY RESPONSIBILITIES
•Build and maintain features in Swift using [SwiftUI / UIKit / both]
•Integrate our REST or GraphQL APIs and handle offline and error states
•Write unit and UI tests and keep the suite green in CI
•Prepare and submit releases through App Store Connect and TestFlight
•Respond to App Store review rejections and resubmit
•Monitor crash reports and performance, and fix regressions on a defined SLA
•Keep App Privacy details and permission prompts accurate as features change
•Support the [number] most recent iOS versions and the current device range
•Review code from [teammates / contractors] and document what you ship
REQUIRED QUALIFICATIONS
•[Number] years building iOS applications in Swift
•At least one app you shipped that is live on the App Store today
•Working knowledge of Xcode, Swift Concurrency, and dependency management
•Experience with signing, provisioning profiles, and the release process
•Comfort with automated testing and crash triage
•[Bachelor's degree in computer science or equivalent practical experience]
NICE TO HAVE
•SwiftUI in production, not only in side projects
•StoreKit and in-app purchase or subscription experience
•Objective-C for legacy code
•CI automation for builds and TestFlight distribution
•Accessibility and localization work
CLASSIFICATION AND COMPLIANCE NOTE (read before posting)
Most full-time iOS developers qualify for the FLSA computer employee exemption,
which requires a qualifying primary duty (systems analysis, programming, or
software design) plus either a salary of at least $684 per week or an hourly
rate of at least $27.63 per hour worked. State law can be stricter than federal
law and the stricter rule wins, so confirm your state before classifying.
Anyone who does not clear both halves of the test is non-exempt: track hours and
pay overtime past forty in a week. This is general information, not legal
advice.
ACCOUNT AND IP NOTE
The Apple Developer Program account, signing certificates, and App Store Connect
listing belong to [Company Name]. The developer is granted access under a named
role and that access is removed at offboarding. A signed intellectual property
assignment is part of the offer package.
EEO STATEMENT
[Company Name] is an equal opportunity employer and provides reasonable
accommodations for the essential functions of this role.
COMPENSATION AND HOW TO APPLY
Compensation: $_ to $_ per year, [equity], [benefits summary]
To apply, email __ with your resume and App Store links to
apps you shipped.
Template 2: Junior / Associate iOS Developer
For a first or second job developer working under review, with the pay test that most often makes a junior role non-exempt written into the compliance note.
Junior / Associate iOS Developer Job Description
JUNIOR IOS DEVELOPER JOB DESCRIPTION
Company: __ ([City, State] / Remote / Hybrid)
Reports to: [Senior iOS Developer / Engineering Manager]
Employment type: Full-time
FLSA status: Check both halves of the test (see classification note)
Compensation: $_ to $_ per year
ABOUT THIS ROLE
[Company Name] is hiring a junior iOS developer to work alongside [name or
role], who will review every change you ship for the first [number] months. This
is a role for someone with real Swift under their belt and a first shipped app,
not for someone who has only finished a course.
POSITION SUMMARY
The Junior iOS Developer implements well-defined features and bug fixes in
Swift, writes tests for the code they touch, and learns our release process by
running supervised builds to TestFlight.
KEY RESPONSIBILITIES
•Implement scoped tickets in Swift with [SwiftUI / UIKit]
•Fix bugs found in crash reports and user feedback
•Write unit tests for the code you change
•Prepare TestFlight builds for internal review under supervision
•Ask for review early and respond to code review comments
•Keep a written log of what you shipped and what broke
REQUIRED QUALIFICATIONS
•Swift fundamentals and at least one app or substantial project you can show
•Familiarity with Xcode, source control, and pull request workflow
•Willingness to work from an existing codebase rather than start fresh
•Clear written communication in [English]
•[Degree, bootcamp, or self-taught: state which you accept]
CLASSIFICATION AND COMPLIANCE NOTE
Junior developers are where the computer employee exemption most often fails.
The exemption needs both a qualifying primary duty and either $684 per week or
$27.63 per hour worked. A junior paid below that floor is non-exempt: track
hours and pay overtime past forty in a week. Unpaid multi-week trial projects
create wage exposure and cost you strong applicants. Pay for any exercise that
takes more than a couple of hours. This is general information, not legal
advice.
EEO STATEMENT
[Company Name] is an equal opportunity employer and provides reasonable
accommodations for the essential functions of this role.
COMPENSATION AND HOW TO APPLY
Compensation: $_ to $_ per year, [benefits summary], [mentorship
and learning budget]
To apply, email __ with your resume and a link to anything
you built.
Still Using Spreadsheets for Onboarding?
Automate documents, training assignments, task management, and track onboarding progress in real time.
Term: [Start date] to [end date], approximately [number] weeks
Rate: $_ per hour, or $_ fixed for the scope below
Classification: Independent contractor (see classification note)
SCOPE OF WORK
[Client Name] is engaging an iOS developer to deliver [new app / specific
feature set / migration / App Store submission] for our [product]. Deliverables:
•[Deliverable 1: for example, a SwiftUI rewrite of the checkout flow]
•[Deliverable 2: for example, StoreKit subscription integration]
•[Deliverable 3: App Store submission and response to review feedback]
•Source code in our repository, with a README a future developer can follow
•Handover session and written notes on outstanding items
WHAT WE PROVIDE
•Apple Developer Program account access under a named App Store Connect role
•API documentation, design files, and a test account
•A named point of contact for decisions and sign-off
•[Test devices, if applicable]
REQUIRED QUALIFICATIONS
•Shipped iOS applications you can demonstrate on the App Store
•Swift and [SwiftUI / UIKit] experience matching our codebase
•Availability of approximately [number] hours per week during the term
•Own equipment, own Xcode setup, own business insurance where applicable
ACCOUNTS, CODE, AND IP
The Apple Developer Program account, signing certificates, App Store Connect
listing, and repository remain the property of [Client Name]. Contractor access
is granted under a named role for the term and revoked at the end of it. Work
made for hire rules do not automatically transfer copyright in commissioned
software, so this engagement includes a written intellectual property assignment
signed before work begins.
CLASSIFICATION NOTE (read before signing)
Contractor status is a legal test, not a budget decision. A developer who works
your hours, uses your equipment, reports to your manager, and works only for you
on your core product for an open-ended period looks like an employee to a
federal or state auditor whatever the contract says. Genuine contract work has a
defined scope, a defined end, contractor control over method and schedule, and a
real business on the other side. Misclassification costs back taxes, back
overtime, and penalties. This is general information, not legal advice.
HOW TO APPLY
Send your rate, availability, App Store links, and two references from clients
whose apps you shipped to __.
Template 5: iOS Developer, App Maintenance and Release Owner
For an app that already exists and that nobody owns since the original developer moved on. Annual compatibility work, certificate renewals, crash fixes, and a written runbook.
iOS Developer, App Maintenance and Release Owner
IOS DEVELOPER JOB DESCRIPTION (MAINTENANCE AND RELEASE OWNER)
Company: __ ([City, State] / Remote)
Reports to: [Operations Lead / Owner / Product Manager]
Employment type: [Full-time / Part-time]
FLSA status: Depends on primary duty (see classification note)
Compensation: $_ to $_ per year
ABOUT THIS ROLE
[Company Name] already has an iOS app. It works, customers use it, and nobody
owns it since [the original developer / the agency] moved on. We are hiring
someone to take custody of it: keep it compliant with each iOS release, fix what
breaks, and ship small improvements. This is not a rewrite.
POSITION SUMMARY
The iOS Developer keeps an existing app healthy: annual OS compatibility work,
crash and bug fixes, dependency and certificate renewals, App Store compliance
updates, and a small queue of improvements agreed each [quarter].
KEY RESPONSIBILITIES
•Take custody of the existing codebase and document how it is built and released
•Test against each new iOS beta and ship compatibility fixes before public release
•Renew signing certificates and provisioning profiles before they expire
•Keep dependencies and the minimum supported OS version current
•Fix crashes and bugs on an agreed severity and response schedule
•Update App Privacy details and permission prompts when data use changes
•Ship [number] small improvements per [quarter] from an agreed backlog
•Keep a written runbook so the next person is not starting from zero
REQUIRED QUALIFICATIONS
•Experience maintaining an iOS codebase you did not write
•Swift, plus Objective-C if our app predates the change
•Confidence with signing, provisioning, and App Store Connect
•Patience for archaeology: reading undocumented code and asking good questions
•[Number] years of iOS experience
CLASSIFICATION AND COMPLIANCE NOTE
Read this role honestly before classifying it. If the primary duty is genuine
programming and software design, the computer employee exemption is available
where the pay test is also met ($684 per week or $27.63 per hour worked). If the
job has drifted into app store administration, support triage, and coordination,
the duties test can fail even though the person works in Xcode every day. Work
that is highly dependent on computers is not the same as computer systems
analysis or programming. Classify on the day, not on the title. This is general
information, not legal advice.
EEO STATEMENT
[Company Name] is an equal opportunity employer and provides reasonable
accommodations for the essential functions of this role.
COMPENSATION AND HOW TO APPLY
Compensation: $_ to $_ per year, [benefits summary]
To apply, email __ with your resume and one example of an
app you inherited and kept alive.
Template 6: iOS Developer, Internal / Business App
For an operational app running on company devices, where your own staff are the users. If the same team also needs an Android build, pair this with the Android developer templates.
iOS Developer, Internal / Business App
IOS DEVELOPER JOB DESCRIPTION (INTERNAL BUSINESS APP)
Company: __ ([City, State])
Reports to: [Operations Director / IT Manager / Owner]
Employment type: Full-time
FLSA status: Exempt (computer employee; confirm state rules)
Compensation: $_ to $_ per year
Distribution: [App Store / Apple Business Manager custom app / managed in-house
distribution: choose the route your organization qualifies for]
operations, and our staff work from iPhones and iPads all day. The app they use
is ours. We are hiring an iOS developer to build and support it. There is no
public App Store listing and no consumer growth target: the users are our own
[number] employees, and the measure of success is whether the work gets done
faster.
POSITION SUMMARY
The iOS Developer builds and maintains our internal iOS application, works
directly with the teams who use it, and handles distribution and device
management with [IT / our MDM provider].
KEY RESPONSIBILITIES
•Build features in Swift against real operational workflows
•Sit with [field staff / warehouse teams] and watch them use the app
•Handle offline behavior, because coverage in the field is unreliable
•Integrate with our [ERP / dispatch / inventory] systems and internal APIs
•Manage distribution to company devices with [our MDM / device management]
•Support users directly when something breaks in the field
•Keep device, OS, and certificate inventories current
REQUIRED QUALIFICATIONS
•[Number] years of iOS development in Swift
•Experience with offline-first data handling and syncing
•Comfort talking to non-technical staff and turning complaints into requirements
•[Experience with mobile device management or enterprise distribution]
•Willingness to visit [sites / the warehouse / the field] regularly
CLASSIFICATION AND COMPLIANCE NOTE
An internal app developer whose primary duty is programming and software design
generally qualifies for the computer employee exemption where the pay test is
met. Two things to watch in an operational setting. First, on-call and after
hours support for field staff is normal here, so define the expectation in
writing before the offer. Second, if the role slides into help desk and device
administration, the duties test can fail and the role becomes non-exempt. This
is general information, not legal advice.
EEO STATEMENT
[Company Name] is an equal opportunity employer and provides reasonable
accommodations for the essential functions of this role.
COMPENSATION AND HOW TO APPLY
Compensation: $_ to $_ per year, [benefits summary], [on-call
policy]
To apply, email __ with your resume and a short note on the
most useful internal tool you have built.
Required Versus Nice to Have on the iOS Stack
Require Swift, shipped App Store apps, and comfort with the release process. Treat named frameworks, specific libraries, and a computer science degree as preferred, because a long required list filters out capable developers whose experience simply came from a different codebase.
One judgment call deserves attention. SwiftUI and UIKit are both current, and many production apps mix them. Asking for both is honest at a company with an older codebase and unnecessary at a company starting fresh, so state which one your app actually uses rather than listing every framework you have heard of.
Requirement
Treat as
Why
Swift
Required
The working language of the platform; Objective-C alone is not enough for new work
Live App Store apps
Required
Publicly verifiable proof of shipping, and the cheapest filter you have
Xcode and the release process
Required
Signing, provisioning, and submission are the job, not an afterthought
Automated testing
Required
One-person teams cannot afford manual regression testing on every release
SwiftUI or UIKit
State which one
Say what your codebase uses; asking for both narrows the pool without reason
Objective-C
Preferred
Required only if your app predates the transition and still carries legacy code
StoreKit and subscriptions
Preferred
Required only if you sell inside the app
Computer science degree
Preferred
Equivalent practical experience is common and productive in mobile work
Adjacent roles have their own lists. If the job is really backend work with a thin app on top, the software engineer templates fit better, and if release testing is the real gap, look at the QA engineer templates instead.
The Apple Account Belongs to the Company, Not the Developer
Enroll the Apple Developer Program under the company as an organization, then add the developer to it under a named role. Organization enrollment requires a legal entity, someone with authority to sign agreements on its behalf, and a D-U-N-S number, which is free but takes time to obtain, so start it before the first day.
The membership costs $99 per year and lapses if nobody renews it. The signing certificates and provisioning profiles expire on their own schedule. Neither of those dates lives anywhere by default, which is how a small company discovers an expired certificate the morning a critical fix needs to ship.
1
Enroll as an organization before the hire starts
Use a company email on a company domain, a company legal entity, and a D-U-N-S number. Individual enrollment is faster and it is the mistake. Start the process early, because verification is not instant.
2
Add the developer under a named role
App Store Connect supports distinct roles with different permissions. Give the developer what the job needs, keep the account holder role with the business, and never share one login across people.
3
Keep signing material where the owner can reach it
Certificates and provisioning profiles should live in company-controlled storage, not on one laptop. If the only copy leaves with a developer, the next release becomes an emergency.
4
Track the renewal dates with the employee record
Program membership, certificates, and any third-party service the app depends on all expire. Attach the dates to the record so a renewal is a task, not a surprise.
5
Reverse every grant at offboarding
Remove App Store Connect access, repository access, API keys, and crash reporting on the same day the laptop comes back. Use the same written list you used to grant them.
Never Let the Developer Register the Account Personally
This is the most expensive shortcut in small-company mobile work. The entity paperwork is not ready, the developer wants to ship, so the Apple Developer Program account gets created under a personal email and the app ships under someone's own name. It works fine until that person leaves, and then the business cannot publish an update to its own app, cannot respond to a review issue, and cannot always recover the listing. Register to the company, hold the signing material centrally, grant named-role access, and put removal on the offboarding checklist next to the laptop and the door key.
Overtime, Contractors, and Who Owns the Code
Most full-time iOS developers are exempt from overtime under the FLSA computer employee exemption, which requires both a qualifying primary duty and a qualifying pay level. The pay half is unusual because it accepts either a salary of at least $684 per week or an hourly rate of at least $27.63 per hour worked.
The rule sits in the federal regulation covering computer employees as exempt professionals, and the Department of Labor restates the same two-part test in Fact Sheet 17E. The duties half is what fails in real roles: work that is highly dependent on computers but is not systems analysis, programming, or software design does not qualify, however senior the title reads.
The computer employee exemption has two halves
The federal rule for computer employees asks for both a qualifying primary duty and a qualifying pay level, and the pay half is unusual because it accepts either a salary of at least $684 per week or an hourly rate of at least $27.63 per hour worked. That hourly alternative exists almost nowhere else in the exemption rules and it matters for part-time and hourly engineering arrangements. The duties half is where real roles fail: the work has to be systems analysis, programming, or software design, and the regulation is explicit that being highly dependent on computers is not enough. Sit with the actual week before you classify, and remember that state law can be stricter than federal law, in which case the stricter rule applies.
Contractor status is a test, not a preference
Hiring the first iOS developer as a contractor is common and often wrong. The classification turns on the economic reality of the relationship: who controls the schedule and method, whose equipment and accounts are used, whether the work is integral to the business, whether the arrangement has a defined end, and whether the worker has a real business serving other clients. A single developer working your hours on your only product for an open-ended term is an employee under that analysis regardless of what the agreement is titled. Getting it wrong costs back taxes, back overtime, and penalties, and the exposure grows quietly for years before anyone notices it.
Commissioned code is not automatically yours
Work created by an employee within the scope of employment is generally a work made for hire, and the employer is the author from the start. Commissioned work from an independent contractor is different: under the Copyright Office guidance, it qualifies as a work made for hire only in a short list of enumerated categories, and software written to order does not sit comfortably in that list. The practical answer is the same either way: a signed intellectual property assignment goes in the offer package for employees and in the engagement agreement for contractors, before the first commit rather than after the relationship sours.
Access is part of the employment record
An iOS hire receives more sensitive access in week one than most roles receive in a year: the repository, the CI pipeline, API keys, crash reporting, analytics, the Apple Developer Program account, and App Store Connect. None of that is tracked by an offer letter. Keep a written access list per role, grant it during onboarding, and reverse it during offboarding on the same day the laptop comes back. Signing certificates and program membership renewals also expire on dates nobody remembers, so store them with the employee record and the renewal date attached rather than in one person's inbox.
Anyone outside the exemption needs hours tracked and overtime paid past forty in a week, which in small mobile teams usually catches juniors at low pay and roles that have drifted into support. Our breakdown of exempt versus non-exempt classification works through both tests, and state law can be stricter than the federal floor.
Code ownership deserves its own paragraph because it surprises people. Work created by an employee inside the scope of employment is generally a work made for hire, but the Copyright Office explains in its circular on works made for hire that commissioned work from an independent contractor qualifies only within a short list of enumerated categories. Custom software is not a comfortable fit, so get a written assignment signed before work begins.
What to Pay an iOS Developer
There is no Bureau of Labor Statistics occupation for iOS developers specifically, so benchmark against software developers, occupation code 15-1252, and adjust for your market and the scope of the role. The federal data covers the entire software developer population and skews toward large employers in expensive metros.
Software Developer Wages, National
According to the Bureau of Labor Statistics Occupational Employment and Wage Statistics survey (May 2025), software developers earned a national median of $135,980 per year, or $65.38 per hour. The annual ladder runs $82,460 at the 10th percentile, $105,210 at the 25th, $171,980 at the 75th, and $214,670 at the 90th (U.S. Bureau of Labor Statistics, OEWS national estimates).
Benchmark
National median (BLS OEWS, May 2025)
How to use it for an iOS role
Software developers (15-1252)
$135,980 per year
The closest classification; iOS developers are counted here
10th percentile, software developers
$82,460 per year
Junior mobile roles outside major tech markets land near this band
25th percentile, software developers
$105,210 per year
A realistic floor for a solo mid-level iOS hire at a small business
75th percentile, software developers
$171,980 per year
Senior or lead mobile roles at product companies
90th percentile, software developers
$214,670 per year
Large-employer senior bands; rarely the right comparison for a small team
Computer programmers (15-1251)
$100,390 per year
Maintenance-heavy work on an existing app benchmarks closer to this
Software QA analysts and testers (15-1253)
$104,300 per year
Use if the role is mostly release testing rather than feature development
Web developers (15-1254)
$92,650 per year
The right anchor only if the app wraps a web experience
For contract work, the hourly ladder is the more useful reference: the same survey puts the median at $65.38 per hour, with the 25th percentile at $50.58 and the 75th at $82.68. Freelance iOS rates commonly sit above the employee equivalent because the contractor carries their own taxes, equipment, insurance, and unpaid gaps between engagements, so compare total cost rather than headline rate.
Publish a good-faith range in the posting. Several states and cities now require it, and our guide to pay transparency laws covers where. Even where nothing requires it, mobile candidates compare offers across a very wide band, and a posting with no number gets skipped by exactly the developers who have options.
Companies Using FirstHR Onboard 3x Faster
Join hundreds of small businesses who transformed their new hire experience.
Screening iOS Candidates Without an Engineering Team
You can evaluate an iOS developer without reading Swift, because the platform makes their work public. Install the apps they shipped and use each one for ten minutes. That single step tells you more about care, judgment, and finishing than an hour of conversation.
Three moments do most of the work: a bad network connection, a wrong password, and a completely empty account. Careful developers handle all three gracefully because they have watched real users hit them. Fast developers ship a spinner that never stops.
Screening step
What it costs
What it tells you
Install and use their shipped apps
Ten minutes each
Polish, error handling, empty states, and whether they finish things
Ask what they owned versus the team
One question
Separates contributors from people who describe someone else's work
Ask what broke in production
One question
Reveals monitoring habits, honesty, and how they respond under pressure
Ask which OS versions they support and why
One question
Shows whether they think about real users or only the newest device
Buy two hours of an outside senior engineer
A few hundred dollars
One technical conversation and one code review, from someone who can judge both
Paid short exercise or code review
Two to four paid hours
Real signal without the unpaid multi-day project that loses strong applicants
References from people who watched them ship
Two calls
Ownership, incident response, and whether the referee would hire them again
Skip the unpaid multi-week build. It filters for availability rather than skill, and it can create wage exposure depending on how the work is structured. Our guide to finding developers for a startup covers sourcing channels that work when you have no engineering brand to trade on.
Hiring an iOS Developer Without an HR Department
Small company mobile hiring fails in three predictable places: one person carries the entire platform, the owner cannot evaluate the skill being hired, and onboarding turns into a scattered pile of access grants nobody wrote down. Each one has a practical fix.
One person holds the whole platform, and there is no second opinion
At a small company the iOS developer is usually the only iOS developer. Nobody reviews the architecture, nobody catches the shortcut, and nobody can ship the app if that person is on vacation during a review rejection. The fix is not a second hire you cannot afford. It is a written release runbook, a documented build, source control the owner can actually reach, and a standing retainer with an outside senior developer for a monthly review and emergency cover. Write both into the job description so the expectation is set before day one rather than discovered during an outage.
You are hiring for a skill you cannot evaluate yourself
Most owners hiring their first mobile developer cannot read Swift, and every candidate sounds competent in an interview. Two cheap moves fix most of the risk. Install the apps the candidate shipped and use them for ten minutes each on a bad connection, a wrong password, and an empty account, which tells you about care and judgment. Then pay an outside senior engineer for two hours to run one technical conversation and one code review. It costs less than a week of the wrong hire and turns an impossible decision into a normal one.
Day one is fifteen access grants and nothing writes them down
A developer hire is mostly access: repository, pipeline, crash reporting, analytics, API keys, test devices, the Apple Developer Program account, App Store Connect under a named role, plus the signed offer and intellectual property assignment. Most small companies grant those over a chaotic first week in five different tools and keep no list, which turns offboarding into a guessing game. FirstHR runs it as one tracked sequence: e-signature for the offer and the IP assignment, documents stored against the employee profile with renewal dates on certificates and program membership, task workflows for each access grant, and the same list reversed when someone leaves. Applicant tracking is coming soon to FirstHR.
Once the offer is signed, the work becomes a repeatable onboarding checklist, and for engineering hires specifically our guide to developer onboarding covers the sequence from access grants through the first shipped change.
Key Takeaways
Name the actual job in the posting: a new build, feature work on an existing app, maintenance of an inherited codebase, and an internal business app attract different people and should not share one description.
Require Swift, live App Store links, and comfort with the release process; treat specific frameworks, libraries, and a degree as preferred so you do not filter out capable developers.
App Store review is a gate you do not control, so state in the posting who owns submissions, resubmissions after a rejection, and privacy disclosure updates.
Enroll the Apple Developer Program under the company with a D-U-N-S number, keep signing certificates centrally, and grant the developer named-role access that offboarding reverses.
The computer employee exemption needs a genuine programming primary duty plus either $684 per week or $27.63 per hour, and junior or support-heavy roles are where it fails.
Benchmark pay to software developers (BLS OEWS, May 2025): a $135,980 national median, with the 25th percentile at $105,210 and the 75th at $171,980.
A developer hire is mostly paperwork and access: the signed offer, the intellectual property assignment, repository and pipeline permissions, API keys, and the Apple accounts, all inside the first two days. FirstHR runs that as one tracked sequence, with e-signature, documents stored against the employee profile, renewal dates on certificates and program membership, and the same list reversed at offboarding. Applicant tracking is coming soon to FirstHR.
Frequently Asked Questions
What does an iOS developer do?
An iOS developer builds and maintains applications that run on iPhone and iPad, almost always in Swift, using Apple’s development tools. The work has four parts that a job description should name separately. The first is building features and integrating APIs, including offline behavior and error states. The second is testing and crash triage against real user volume. The third is release management: preparing builds, distributing them through TestFlight, submitting to App Store review, and responding when a submission is rejected. The fourth is compliance work that never appears on a job board, meaning privacy disclosures, permission prompts, and the annual scramble to stay compatible when a new operating system version ships. At a small company one person carries all four, which is exactly why the posting has to say so.
What should an iOS developer job description include?
It should include nine things: what the app is and who uses it, whether the job is a new build or maintenance, the language and framework stated exactly (Swift with SwiftUI or UIKit), the supported operating system and device range, testing and crash triage expectations, who owns App Store submissions, the FLSA classification, a real pay range, and a line stating that the Apple Developer Program account and signing certificates belong to the company. The last one gets left out of nearly every posting and it is the one that costs the most later. Ask for a live App Store link in the application itself rather than a portfolio site: it is a free filter that separates people who have shipped from people who have studied.
Are iOS developers exempt from overtime?
Usually yes, but the test has two halves and both have to pass. The FLSA computer employee exemption requires a qualifying primary duty, meaning systems analysis, programming, or software design, plus either a salary of at least $684 per week or an hourly rate of at least $27.63 per hour worked. That hourly alternative is specific to computer employees and it matters for part-time engineering arrangements. Two situations commonly fail the test. A junior developer paid below the floor is non-exempt no matter what the offer letter says. A role that has drifted into app store administration, user support, and coordination can fail the duties half even though the person works in Xcode daily, because the regulation says that being highly dependent on computers is not the same as programming. State law can be stricter, and the stricter rule wins.
How much should I pay an iOS developer?
There is no Bureau of Labor Statistics occupation for iOS developers specifically, so benchmark against software developers, occupation code 15-1252. According to the Bureau of Labor Statistics Occupational Employment and Wage Statistics survey (May 2025), software developers earned a national median of $135,980 per year, with the 10th percentile at $82,460, the 25th at $105,210, the 75th at $171,980, and the 90th at $214,670. That population skews toward large employers in expensive metros, so a small business outside a major tech market should expect to sit between the 10th and 50th percentiles for a mid-level hire. For contract work, the hourly ladder is more useful: a median of $65.38 per hour with the 25th percentile at $50.58 and the 75th at $82.68. Publish a good-faith range where pay transparency rules apply.
Should I hire an iOS developer as an employee or a contractor?
Hire an employee when the app is core to the business and the work continues indefinitely. Hire a contractor when you have a defined scope with a defined end, such as a first version, a specific feature, or a migration. Classification is a legal test, not a budget preference: it turns on who controls the schedule and method, whose equipment and accounts are used, how integral the work is to the business, whether the arrangement has an end date, and whether the worker runs a real business serving other clients. A sole developer working your hours on your only product for an open-ended period is an employee under that analysis whatever the agreement says. Either way, get a signed intellectual property assignment before the first commit, because commissioned software does not transfer automatically.
Should the developer set up the Apple Developer Program account?
No. Enroll the company as an organization and add the developer to it under a named role. Organization enrollment requires a legal entity, the authority to sign agreements on its behalf, and a D-U-N-S number, which is free but takes time to obtain, so start it before the developer's first day. Membership costs $99 per year and lapses if nobody renews it. The failure mode is well known: the first developer registers the account under a personal email because the entity paperwork is not ready, and when that person leaves the business cannot ship an update to its own app. Recovery is slow and sometimes impossible. Keep the account, the signing certificates, and the App Store Connect listing in company hands, and put access removal on the offboarding checklist.
How do I evaluate an iOS developer without a technical team?
Use the platform to your advantage: iOS work is publicly verifiable in a way most engineering is not. Ask for live App Store links, install the apps, and use each one for ten minutes on a weak connection, with a wrong password, and from an empty account. Polish, error handling, and empty states tell you more about judgment than any resume. Then ask five non-technical questions: what did you own versus the team, what broke in production and how did you find out, which iOS versions do you support and why, what would you rebuild, and what did you decide not to build. Finally, pay an outside senior engineer for two hours to run one technical conversation and one code review. Applicant tracking is coming soon to FirstHR, and until then a simple shared scorecard keeps the process consistent.
