App Development FAQ

Start with one language and one platform. If you want to build iOS apps, learn Swift using Apple's free SwiftUI tutorials. For Android, start with Kotlin. If you want both platforms at once, look at Flutter (Dart) or React Native (JavaScript).

Don't try to learn everything at once. Pick one path and build something small — a to-do list, a calculator, a tip splitter. The goal is to finish something, not to build the perfect app on day one.

No. I know many successful app developers who are entirely self-taught, and some of the best engineers I've worked with don't have CS degrees. What matters is your ability to solve problems, learn continuously, and ship working software.

A degree can provide a strong foundation in algorithms, data structures, and theory — and it opens doors at some large companies. But it's neither necessary nor sufficient. Your portfolio of shipped apps will speak louder than any qualification.

Start with the platform you use every day. If you carry an iPhone, build for iOS. If you're on Android, build for Android. You'll have much better instincts about what feels right when you're a daily user of the platform.

If your goal is to reach the widest audience quickly, consider cross-platform frameworks like Flutter or React Native. But understand the trade-off: you gain reach but lose some platform-specific polish.

For indie developers, I generally recommend starting native on one platform, launching, validating your idea, and then expanding to the other platform once you have traction.

If you're consistent, you can build and ship a simple but functional app within 3-6 months of starting to learn. That doesn't mean you'll be an expert — it means you'll have enough skill to turn an idea into something real.

The honest truth is that you never stop learning. After 12+ years, I still learn new things regularly. The key is to get comfortable with that feeling of not knowing everything — it's the permanent state of being a developer.

For iOS development, you need a Mac — any Mac that can run the latest version of Xcode. A MacBook Air is more than enough to start. You don't need the most expensive model.

For Android development, any modern computer (Mac, Windows, or Linux) will work. Install Android Studio and you're good to go.

For cross-platform development (Flutter, React Native), you can develop on any operating system, though you'll still need a Mac to build the iOS version.

You do not need a physical device to start — simulators and emulators are included free with the development tools. But testing on a real device before you ship is important.

It depends on your goal:

• Swift — Best for iOS apps. Clean syntax, beginner-friendly, and Apple provides outstanding learning resources.
• Kotlin — Best for Android apps. Modern, concise, and Google's preferred language for Android.
• JavaScript/TypeScript — Best for web apps and cross-platform mobile (via React Native). Massive ecosystem and community.
• Dart — Used with Flutter for cross-platform apps. Gaining popularity fast.
• Python — Not for mobile apps directly, but an excellent first language for learning programming concepts.

The "best" language is the one you'll actually stick with. Pick one and commit to it for at least 3 months before considering switching.

There are brilliant free resources available:

• Apple's SwiftUI Tutorials — Hands-on, project-based, and official. The best starting point for iOS.
• 100 Days of SwiftUI by Paul Hudson (Hacking with Swift) — Structured daily curriculum that builds real skills.
• Google's Android Basics with Compose — Official Kotlin/Jetpack Compose course.
• CS50 by Harvard (free on edX) — Outstanding introduction to computer science fundamentals.
• freeCodeCamp — Great for JavaScript and web development fundamentals.
• YouTube — Channels like Sean Allen, CodeWithChris, and Traversy Media offer quality tutorials.

Tutorial hell is when you endlessly consume learning content without actually building anything original. Here's how to escape it:

1. Follow the 70/30 rule — Spend 30% of your time learning (tutorials, docs, courses) and 70% building your own projects.
2. Build variations — After completing a tutorial, modify the project. Change the design, add a feature, or combine two tutorial concepts.
3. Set a ship date — Give yourself a deadline to publish something on the App Store or Play Store. The pressure of a real deadline forces you to stop learning and start finishing.
4. Embrace being stuck — When you're building on your own and get stuck, that's where real learning happens. Use documentation, Stack Overflow, and AI tools to work through problems.

Yes, but wisely. AI tools are powerful accelerators, but they can also become a crutch that prevents you from truly understanding what you're building.

Good uses of AI when learning:

• Explaining error messages and why they occur
• Comparing approaches ("What's the difference between X and Y?")
• Reviewing your code and suggesting improvements
• Generating boilerplate so you can focus on logic

Bad uses of AI when learning:

• Copying entire solutions without understanding them
• Skipping the struggle of figuring things out yourself
• Using it as a substitute for reading documentation

The main development environments are all free:

• Xcode (macOS only) — Apple's IDE for building iOS, iPadOS, macOS, watchOS, and tvOS apps. Free from the Mac App Store.
• Android Studio (Mac/Windows/Linux) — Google's IDE for Android development. Free to download.
• VS Code (Mac/Windows/Linux) — Lightweight code editor, great for Flutter, React Native, and web development. Free.

You'll also want to learn Git for version control (tracking changes to your code) and use GitHub to store your projects. Both are free for personal use.

Native (Swift for iOS, Kotlin for Android) gives you the best performance, the most platform-specific features, and the smoothest user experience. Apple and Google's own apps are built natively.

Cross-platform (Flutter, React Native) lets you write one codebase that runs on both iOS and Android. This is great for startups, MVPs, and teams with limited resources.

My recommendation:

• If you want the deepest understanding of mobile development → go native.
• If you want to ship to both platforms quickly → go cross-platform.
• If you already know JavaScript → React Native is a natural fit.
• If you're starting completely fresh → Flutter has an excellent developer experience and growing ecosystem.

There's no wrong answer. The best framework is the one that gets your app into people's hands.

Not necessarily. Many successful apps run entirely on-device — calculators, note-taking apps, utilities, offline games. Start simple.

You'll need a backend if your app requires:

• User accounts and authentication
• Syncing data between devices
• Social features (messaging, feeds, sharing)
• Storing data in the cloud

When you do need a backend, services like Firebase, Supabase, or CloudKit (Apple) handle the heavy lifting so you don't have to build a server from scratch. These "Backend-as-a-Service" platforms have generous free tiers.

No-code tools like FlutterFlow, Adalo, Glide, and Bubble can help you prototype ideas quickly or build simple apps without writing code. They're great for validating whether anyone actually wants what you're building.

However, if you're serious about app development as a skill or career, learning to code gives you far more control, flexibility, and earning potential. No-code tools hit a ceiling when your app needs custom behaviour, performance optimisation, or complex logic.

Think of no-code as a prototyping tool, not a replacement for learning to code.

Good news: you don't need to be a designer. Both Apple and Google provide comprehensive design systems that do the heavy lifting:

• Apple's Human Interface Guidelines — Follow these and your iOS app will look and feel native automatically.
• Google's Material Design — Same principle for Android apps.

Beyond that, follow these principles:

• Consistency — Use the same spacing, fonts, and colours throughout your app.
• White space — Don't cram things together. Give elements room to breathe.
• Hierarchy — Make the most important thing on each screen the most prominent.
• Simplicity — When in doubt, remove things. The best apps do fewer things exceptionally well.

Yes — at least roughly. You don't need pixel-perfect mockups, but you should sketch out the main screens and user flows before writing code. This saves you from building the wrong thing.

For quick wireframing, try:

• Paper and pen — Still the fastest way to explore ideas.
• Figma (free) — Industry-standard design tool with great mobile app templates.
• Apple's design resources — Free Figma and Sketch templates for iOS components.

Spend a day sketching and thinking before spending a week coding. Your future self will thank you.

Extremely important. Roughly 1 in 5 people has some form of disability. Building accessible apps isn't just the right thing to do — it also increases your potential user base and is a requirement for many enterprise contracts.

Start with these basics:

• Support Dynamic Type (iOS) or scalable text (Android) so users can adjust font sizes.
• Add VoiceOver/TalkBack labels to all interactive elements.
• Ensure sufficient colour contrast (4.5:1 ratio minimum for body text).
• Support Dark Mode — it's not just aesthetic, it helps users with light sensitivity.
• Test your app with the screen reader turned on. You'll catch issues you never considered.

The process for both stores follows the same broad steps:

1. Create a developer account — Apple Developer Program costs $99/year (USD). Google Play Developer costs a one-time $25 (USD) fee.
2. Prepare your app listing — Screenshots, app icon, description, privacy policy, and category.
3. Upload your build — Through Xcode (iOS) or the Google Play Console (Android).
4. Submit for review — Apple reviews typically take 24-48 hours. Google is usually faster.
5. Launch — Once approved, your app is live worldwide (or in the countries you choose).

Having had apps featured by Apple (including Game of the Day), here's what I've learned increases your chances:

• Polish your app obsessively — The editorial teams notice quality. Smooth animations, thoughtful interactions, and attention to detail matter.
• Adopt new platform features quickly — When Apple launches a new API or design change, be among the first to implement it. Apple loves to showcase apps that embrace their latest technology.
• Tell a compelling story — Your app description and marketing materials should communicate why your app exists and who it helps.
• Localise your app — Supporting multiple languages shows commitment and expands your reach.
• Support accessibility — Apple in particular values apps that are usable by everyone.
• Build a beautiful app page — Your screenshots and preview video are your shop window. Make them count.

There's no guaranteed formula, but consistently shipping high-quality updates puts you on their radar.

Your first users will come from your existing network and targeted communities:

• Share with friends and family — Ask them to download, use, and leave honest reviews.
• Post in relevant communities — Reddit, indie hacker forums, Product Hunt, and niche communities where your target users gather.
• Build in public — Share your development journey on Twitter/X, Threads, or TikTok. People love following the process.
• App Store Optimisation (ASO) — Choose your keywords carefully. Your app name, subtitle, and keyword field directly affect discoverability.
• Create a simple landing page — Even a one-page site gives you something to share and improves your legitimacy.

Don't spend money on ads until your app has been validated by real users who found it organically. If people don't want it for free, they won't want it through a paid ad.

The main monetisation models are:

• Paid upfront — Users pay once to download. Simple but hard to compete with free alternatives. Works best for utility apps with clear, immediate value.
• Freemium — Free to download with optional in-app purchases for premium features. This is the most common model for indie developers.
• Subscriptions — Recurring revenue (weekly, monthly, or yearly). Best for apps that provide ongoing value like content, services, or productivity tools.
• Ads — Free app supported by advertising. Can work at scale but provides a worse user experience. Consider using ads sparingly or offering an ad-free paid tier.
• In-app purchases — Consumable (coins, credits) or non-consumable (unlock a level pack). Common in games.

It's possible, but it's not easy and it's rarely quick. The developers who earn a sustainable income from indie apps typically:

• Have multiple apps generating small amounts of revenue that add up.
• Focus on niche markets where competition is lower and users are willing to pay.
• Build apps that solve real, specific problems rather than broad, generic ones.
• Invest in retention and updates — the app is a living product, not a one-time release.

A more realistic path for most people: build apps as a side project while working a full-time job. Let revenue grow organically. If and when it reaches a sustainable level, you can consider going full-time indie.

Having app development skills also opens up freelance, consulting, and employment opportunities that can be very well-paid regardless of whether your own apps generate income.

Both Apple and Google take a 15-30% commission on app sales and in-app purchases:

• Apple — 30% standard rate, reduced to 15% if you earn under $1M/year (Small Business Program) or for subscription revenue after a user's first year.
• Google — 15% on the first $1M/year in revenue, then 30% after that.

For most indie developers earning under $1M, you'll pay 15% on both platforms. Factor this into your pricing from the start.

Your portfolio should demonstrate three things: you can build, you can ship, and you can think.

• Ship real apps — Having even 2-3 apps live on the App Store is more impressive than 20 GitHub repos with unfinished projects.
• Show your process — Write brief case studies explaining the problem, your approach, and what you learned.
• Demonstrate range — Build different types of apps (a game, a utility, a social feature) to show versatility.
• Contribute to open source — Shows you can work with existing codebases and collaborate with others.
• Keep a blog or social presence — Writing about what you're learning signals curiosity and communication skills.

Quality over quantity. Three polished, well-documented apps will beat fifteen half-finished ones every time.

Both paths are viable, but they suit different people:

Full-time employment is better if you:

• Want structured mentorship and learning from senior engineers
• Value stable income and benefits
• Want to work on larger-scale products
• Are early in your career and need to build experience quickly

Freelancing is better if you:

• Have enough experience to deliver independently
• Want flexibility and variety in your projects
• Are comfortable with irregular income
• Want to build your own apps on the side

Many developers do both at different stages. Starting with employment gives you skills, connections, and financial stability that make freelancing or indie development much more sustainable later.

There are millions of apps on the stores, but the majority are abandoned, poorly made, or solving problems nobody has. The bar for quality is actually quite achievable if you put in genuine effort.

The market isn't saturated — it's noisy. There's a big difference. New apps succeed every day because they:

• Solve a specific problem better than existing solutions
• Target an underserved niche
• Offer a noticeably better user experience
• Take advantage of new platform capabilities

Don't try to compete with Instagram or Spotify. Find a smaller, more specific problem and solve it brilliantly. There's always room for something genuinely well-made.

This is the single most common problem I hear about, and I've struggled with it myself. Here's what works:

1. Reduce scope ruthlessly — Your first version should do one thing. Not three features, not five screens. One core thing, done well.
2. Set a hard deadline — "I will submit to the App Store by [date]." Tell someone so there's accountability.
3. Build the boring parts first — Settings screens, onboarding, and error states are often what people skip. Doing these first means you're closer to "done" when motivation dips.
4. Accept imperfection — Version 1.0 doesn't need to be perfect. It needs to exist. You can improve it forever after launch.
5. Work in small, daily sessions — 30 minutes every day beats an 8-hour weekend sprint. Consistency compounds.

Progress in programming is rarely linear. You'll have days where everything clicks and days where nothing makes sense. That's normal.

• Track small wins — Keep a "done" list alongside your to-do list. Looking back at what you've accomplished is surprisingly motivating.
• Build things you actually want to use — If your own app solves a problem you personally have, you'll naturally be more invested in finishing it.
• Find a community — Join a Discord, subreddit, or local meetup for app developers. Seeing others at similar stages is encouraging.
• Compare yourself to your past self, not others — Someone on Twitter shipping their 50th app is not your benchmark. Your benchmark is you, three months ago.
• Take breaks without guilt — Burnout kills more projects than lack of skill. Step away, come back refreshed.

Ship something.

Not tomorrow, not when it's perfect, not when you've finished one more course. Start building something small today, and commit to publishing it on the App Store or Play Store within the next few weeks.

The gap between "learning to code" and "being a developer" is crossed by shipping. Every app I've built — from the first terrible one to the ones Apple featured — taught me things that no tutorial ever could.

You'll learn more from launching one imperfect app than from completing a hundred tutorials. Start today.