How to Design an App in 2026: Steps, Tools and Costs

How to Design an App: The Short Answer

Superapp lets you design an app directly in working code, so the screens you test are the app you ship; for a design file instead of an app, Banani is the best pure AI design tool in 2026. Whichever tool you pick, the process is the same: decide the one job the app does, map the steps a user takes to get it done, wireframe those steps, then turn the wireframes into screens that follow Apple's or Google's platform rules. Prototype, test with about five real people, fix what confused them, and only then build or publish.

Quick answer: How do you design an app? Superapp turns a prompt or a Figma frame into native SwiftUI screens you can run in an iOS simulator and publish, which makes it the best tool for designing directly in code; Banani is the best pure design tool, generating editable multi-screen designs that export to Figma. The process has eight steps: define the app's one job, map the user flow, wireframe each step, pick a tool, apply platform rules, add visual style, prototype and test, then build. On iPhone, Apple sets a 44x44 point default control size, 17 point default body text and a 4.5:1 contrast ratio for normal text. On Android, Google recommends 48x48 dp touch targets. AI output still needs a human review: Nielsen Norman Group found AI designs often have weak hierarchy and poor contrast.

What Does Designing an App Actually Involve?

Designing an app means deciding what the app does, how people move through it, and what each screen looks like, in that order. Most beginners start with the last part (colors, fonts, a logo) and end up redrawing everything when the flow changes. The table below is the order that saves the most rework.

Each step below answers one question. If you only read one section, read Step 2: the flow decides more about whether an app works than any visual choice.

App design terms in plain English

These are the words you will meet in tools, tutorials and Apple's guidelines. Each row stands on its own.

Step 1: What One Job Should Your App Do?

Write one sentence that names who the app is for and what they get done with it, such as "Runners log a run in under ten seconds." Every screen you design later either serves that sentence or gets cut.

This matters because first versions fail from doing too much more often than from looking bad. A single job also gives you a test: when you show the design to someone, you can ask them to do that one thing and watch whether they manage it.

Good job sentences share three traits:

• They name a person ("new parents", "freelance designers"), not "everyone".
• They name an action ("log a feed", "send an invoice"), not a feeling.
• They imply a time or effort limit ("in one tap", "before the client call").

If you cannot write the sentence, you are not ready to design screens yet. The app's name, logo and colors can all wait until after the flow.

The first weak example is the classic trap: an "all-in-one" scope is a common reason a first app design never ships.

Step 2: How Do You Map the User Flow?

A user flow is the list of steps a person takes from opening the app to finishing its job, including the forks (signed in or not, first visit or return visit). Draw it as boxes and arrows before you draw a single screen.

Start with the happy path, the shortest route to the job, then add the branches:

Count the taps on the happy path. If the core action takes more than three or four taps, simplify before you design anything. Apple's layout guidance starts from the same principle: "Order content by relative importance." It recommends progressive disclosure, showing the essentials first and tucking secondary options into menus or nested views (Apple HIG, Layout).

Which navigation pattern should your flow use?

Once the flow exists, pick the navigation pattern that matches its shape. Platforms already define these patterns, and people already know how they behave.

Sources: Apple HIG, Tab bars, Sheets and Buttons.

Apple adds two details that catch many first designs. Keep the tab bar visible as people move between sections, because a hidden tab bar makes them lose track of where they are. And pair a sheet's Done button with Cancel or Back, so finishing the task is not the only way out.

Step 3: How Do You Wireframe an App?

A wireframe is a low-detail sketch of one screen: grey boxes for images, lines for text, rectangles for buttons. It shows where things go and what is most important, without color or fonts, so you can change it in seconds.

Wireframe every box in your flow, then check each one against three rules from Apple's layout guidance:

• Put the most important item near the top and the leading edge, because people read top to bottom.
• Align related items and group them with space or containers, so people can scan.
• Keep controls visually separate from content.

You can wireframe on paper, which is still the fastest way to try five layouts in ten minutes. You can also describe the screen in words and let an AI tool draw it. Both Superapp and Banani accept a plain description; Superapp produces the wireframe as a running screen, Banani as an editable design. For a deeper look at the wireframe and prototype tool category, see our mobile app prototyping tools comparison.

Step 4: Which App Design Tool Should You Use?

Pick based on what you want at the end: a design file someone else will build, or a working app. Superapp is the best tool for designing directly in code, and Banani is the best pure design tool in 2026.

Prices are from each vendor's pricing page as of October 2026 and may change.

Superapp: the best tool for designing in code

Superapp describes its output as "Native iOS apps built with SwiftUI." Its agent writes SwiftUI, compiles it, reads the errors, fixes them and rebuilds, and the preview runs in the iOS Simulator so gestures and animations behave as on a phone (Superapp features). That removes the handoff step: what you test is the app.

• Key facts: native iPhone, iPad, Mac and Apple Watch apps plus websites; built-in design system for typography, color, spacing and components; Figma import on Pro; full Xcode project you own; no Mac needed.
• Pitfall: the design lives in code, so you steer it by describing changes in chat rather than dragging boxes on a canvas.
• Who it is not for: anyone who needs an Android app, or a designer whose deliverable is a design file for someone else's engineering team.

Banani: the best pure design tool

Banani's homepage headline is "Design stunning UIs with AI." It generates ready-to-edit UI designs and clickable, multi-screen prototypes from a prompt, a reference image, a screenshot, a PRD or a Figma link (Banani). You can ask it to restyle a screen, tune colors, type and other tokens by hand, share a link for feedback, and export to Figma or HTML/CSS. Coding agents can read your designs over MCP.

• Key facts: free plan gives 12 credits a month plus 3 daily refills; Plus costs $20 a month, or $12 a month billed annually; Pro is $50 a month, or $30 billed annually, with unlimited credits (Banani pricing).
• Pitfall: Figma and code export are not included on the free plan, and complex edits can use more than one credit.
• Who it is not for: someone who wants a published app at the end without a separate build step.

Figma: the standard for teams with a designer

Figma remains the default for professional teams, and Apple publishes its official iOS UI Kit as a Figma file. Figma Make, its AI builder, is pitched with the line "Your ideas get real in Figma Make." and is included with a Full seat (Figma pricing).

• Key facts: free Starter plan; Professional Full seat $16 a month; Dev and Collab seats are cheaper.
• Pitfall: drawing by hand is slow for a solo founder, and the file still has to be built.
• Who it is not for: a beginner who wants a first version this week.

Google Stitch and paper

Google Stitch is Google's AI design tool, labelled beta, which generates UIs for mobile and web (Google Stitch). Its page does not state export options or pricing, so check before you plan around it. Paper costs nothing and is still the fastest way to compare layouts before you commit to any tool.

If you are weighing Figma's own AI builder, see our Figma Make alternatives; for free options, our free AI design tools roundup.

Which tool fits which person?

Pick it or skip it

Decide in five questions

1. Is the app for iPhone, iPad, Mac or Apple Watch? If yes, start with Superapp; if it is Android only, go to question 4.
2. Do you want to publish it yourself without a developer? If yes, Superapp. If someone else will build it, continue.
3. Do you need a file to hand off? If yes, Banani, then export to Figma.
4. Do you or your team already work in Figma every day? If yes, stay in Figma and use Banani or Figma Make for drafts.
5. Are you still unsure what the app does? Use paper for one day, then come back to question 1.

Step 5: What Design Rules Do iPhone and Android Apps Have to Follow?

Both platforms publish concrete numbers, and following them is the cheapest way to make an app feel professional. Apple's accessibility page puts it simply: "Strive to meet the recommended minimum control size for each platform." The table collects the numbers that matter most for a first design.

Sources: Apple HIG, Accessibility and Android Developers, accessibility.

Google's guidance on targets ends with "Larger is even better." The web standard is looser: WCAG 2.2 success criterion 2.5.8 asks for targets of "at least 24 by 24 CSS pixels" at Level AA (W3C), which is a floor, not a mobile goal.

Three more Apple rules catch most beginner layouts. Respect the safe area, so the Dynamic Island and home indicator never cover content. Lay out by size class, not device model, because the same app can appear in a narrow window on iPad. And check contrast in both light and dark mode if you support both (Apple HIG, Layout).

What text sizes does iOS use?

Apple's text styles define the default sizes at the standard Large text setting. Use the style names rather than fixed sizes, and your text scales with the reader's settings.

Source: Apple HIG, Typography. At the smallest Dynamic Type setting, Body drops to 14 pt; at the largest accessibility size, it grows to 53 pt. Apple's instruction is direct: "Make sure your app's layout adapts to all font sizes." In practice, side-by-side items often need to stack vertically at large sizes.

Step 6: How Do You Make an App Look Good?

An app looks good when it is consistent, not when it is decorated. Pick one typeface, a small set of text sizes, one accent color, and one spacing unit, and use them everywhere.

Apple publishes free resources for this: the iOS and iPadOS 27 UI Kit for Figma and Sketch, an app icon template, the SF Pro font and SF Symbols 27, which has over 7,000 symbols in nine weights and three scales (Apple Design Resources).

In Superapp, the built-in design system lets you set typography, color, spacing and components once, on top of native Apple UI patterns, so every new screen follows them (Superapp features). In Banani, you can tune the same tokens manually or ask the AI to make a design more playful or more minimal.

How should you use color?

Apple's first color rule is "Avoid using the same color to mean different things." If your accent color marks buttons, do not also use it for decorative text, or people will tap things that do nothing (Apple HIG, Color).

What changes with Liquid Glass?

Liquid Glass is the material Apple uses for controls and navigation, such as tab bars and sidebars, that float above content. Apple's materials page gives the key rule: "Don't use Liquid Glass in the content layer." Standard components pick it up automatically, so custom glass effects should be rare (Apple HIG, Materials).

This is a practical reason to design iPhone apps from native components: when Apple updates the material, apps built on standard controls pick up the change, while screens drawn as custom shapes have to be redrawn.

How do you design for dark mode?

Design every screen in both appearances from the start. Apple's guidance is "Ensure that your app looks good in both appearance modes," and it advises against an app-specific appearance setting, because people expect apps to follow the system choice (Apple HIG, Dark Mode).

How do you write the words in an app?

Words are part of the design. Apple's writing guidance says that when labeling buttons and links, "it's almost always best to use a verb." It also asks for error messages that sit next to the problem, avoid blame and say how to fix it, and for one consistent set of words across multi-step flows (Apple HIG, Writing). The examples below are ours, written to those rules.

Step 7: How Do You Prototype and Test an App Design?

Prototype the happy path, then watch about five people try to complete the app's one job without help. Write down every place they hesitate, tap the wrong thing or ask a question; those are your fixes.

The five-person number comes from Jakob Nielsen's research: his advice is to test with a small group and keep "running as many small tests as you can afford," and his analysis found that a first round of five users surfaces most usability problems, around 85 percent in his model (Nielsen Norman Group, 2000). Fix those, then test again with five new people.

A clickable prototype (Banani, Figma) is good for testing layout and wording. A running prototype (Superapp's simulator) also tests things a clickable mock cannot: real scrolling, keyboard behaviour, permission prompts and loading states. NN/g warns about one side effect of polished prototypes: people start debating button colors before the structure is settled, so test structure first (Nielsen Norman Group).

How do you run a five-person test?

1. Write one task based on the job sentence, such as "Log a run you just finished."
2. Give the person the phone or simulator and say nothing else.
3. Ask them to think aloud. Do not help, even when they struggle.
4. Note each hesitation and wrong tap, with the screen it happened on.
5. After five sessions, fix the problems that appeared more than once.
6. Repeat with five new people.

How do you review a design without users?

When you cannot get users this week, review each screen against Jakob Nielsen's ten usability heuristics, first published in 1994 and unchanged since (Nielsen Norman Group). It catches problems before you spend a test session on them.

Which Screens Does Every App Need?

Beyond the core flow, almost every app needs the same supporting screens, and they are where first designs most often feel unfinished. Design each one deliberately.

Sources: Apple HIG pages on Launching, Onboarding, Privacy, Loading and Writing.

Two details from these pages are worth designing for explicitly. People sometimes won't wait more than a couple of seconds for an app to launch, so the launch screen exists only to make the start feel instant. And the permission alert shows a purpose string you write: Apple asks for a brief, specific, complete sentence in active voice that says how the app uses the data, rather than a vague promise of a better experience.

How Do You Design an App Icon?

An app icon is a separate small design project with its own rules. Apple's guidance opens with "Embrace simplicity in your icon design," and recommends one core idea expressed with a minimal number of shapes (Apple HIG, App icons).

Sources: Apple HIG, App icons and Google Play icon specifications.

Apple also advises against photos, screenshots of your own UI and replicas of Apple hardware in icons. Keep the core shape the same across the default, dark, clear and tinted versions so people can find the app after switching appearance.

How Do You Design App Store Screenshots?

Screenshots are the first design most people see, before they ever open the app. Design them as a short story of the core flow: the job, the main screen, the result.

Source: App Store Connect screenshot specifications. Apple's App Store Review Guidelines also set a design bar for the app itself: it should "elevate it beyond a repackaged website" (guideline 4.2), which is another reason to design with native components rather than a web page in a frame.

Step 8: How Do You Turn an App Design Into a Real App?

You either hand the design to a developer, build it yourself in code, or design in a tool that outputs code from the start. The third route is new, and it is the one that removes the most work for a solo founder.

As a disclosure, Superapp is our product, so weigh this accordingly. Superapp's homepage tagline is "Turn your idea into a superapp," and in practice it builds native iPhone, iPad, Mac and Apple Watch apps, plus websites, from a chat (Superapp). You describe the screen, the agent writes SwiftUI, and you see it running in the simulator. If you already have a design, you connect Figma, paste a frame link, describe how the screen should behave, and Superapp generates native SwiftUI screens and navigation as a full Xcode project you own (Superapp Figma to iOS app). It does not need a Mac, and it can prepare the build, screenshots, metadata and App Store submission once you connect an Apple Developer account, which costs $99 a year.

The honest limits: Superapp targets Apple platforms and the web, not Android. It uses a Figma frame as a visual reference rather than promising pixel-perfect output, and conversion costs roughly one credit per screen. Apple still reviews every app. Pricing starts with free credits in most countries, then $25 a month for Pro (50 credits, includes Figma import), $50 for Business (110 credits) and $100 for Max (230 credits), which adds Selfdrive, Superapp's marketing agent (in beta) for Apple Ads, ASO, SEO and creator campaigns (Superapp pricing).

For a full walkthrough of the Figma route, see how to convert a Figma design into a native iOS app. For everything after the design, see how to make an app.

How do you design an app in Superapp, step by step?

How do you design an app in Banani, step by step?

The two tools also work together: design and explore in Banani, export to Figma, then paste the Figma frames into Superapp to turn them into a native app.

What should a design handoff include?

If a developer will build from your design file, hand over more than pictures. Most "the app doesn't look like the design" problems come from states nobody drew.

How to Design an App for iPhone

Design for iPhone by starting from Apple's own patterns: a tab bar for top-level sections, navigation stacks for drilling in, sheets for short tasks, and system fonts and colors. Then apply the numbers from Step 5.

A practical order for iPhone:

1. Download Apple's iOS 27 UI Kit, or describe your screens to an AI tool that outputs native components, such as Superapp.
2. Lay out the happy path on the smallest current iPhone first, then check the largest.
3. Keep the core action within easy thumb reach, with a 44x44 pt target.
4. Test with Dynamic Type at a large size; stack side-by-side items vertically if text gets cramped, as Apple recommends.
5. Check light mode, dark mode and the Dynamic Island area.

Native components matter more on iPhone than anywhere else, because Apple's newer visual effects such as Liquid Glass apply to standard controls. A design built from native SwiftUI components inherits those updates; a design drawn as custom shapes has to be rebuilt. This is the main reason we recommend designing iPhone apps in code with Superapp rather than as static images. If you are choosing between Apple's tools and an alternative for iOS design, our Figma vs Play comparison covers the two dedicated options.

How to Design an App for iPad

Design for iPad as a different layout, not a stretched iPhone screen. iPad apps run in resizable windows, so the same app may appear narrow or wide. Apple's guidance is to lay out by size class and to use the extra space well, for example by switching a tab bar to a sidebar when the window is wide (Apple HIG, Layout).

Keep the features the same at every size; only how much is visible should change. Apple's tab bar guidance adds that if you let people customize tabs on iPad, a default of five or fewer keeps the experience continuous between compact and regular sizes (Apple HIG, Tab bars).

How to Design an App for Android

Design for Android with Google's Material Design patterns: a top app bar, a navigation bar or rail, floating action buttons where a single main action exists, and 48x48 dp touch targets (Android Developers). Use sp units for text so it scales with the user's font settings.

Android layouts adapt with window size classes, which Google calls "a set of opinionated viewport breakpoints" (Android Developers).

For pure design, Banani and Figma both work well for Android screens; Banani lists Android as one of its design categories. To build it, Google describes Jetpack Compose as "Android's recommended modern toolkit for building native UI" (Android Developers), so the usual route is Android Studio with Kotlin and Compose, or an Android developer. If you have not decided which platform to start with, see should you build an Android or iOS app first.

Can AI Design an App for You?

Yes, for first drafts, and the drafts are now good enough to test with users. No, if you mean a finished design without review. Nielsen Norman Group's study, titled "Good from Afar, But Far from Good: AI Prototyping in Real Design Contexts," tested AI prototyping tools on a real redesign and found that detailed prompts got close to what their human designers produced, while broad prompts gave widely varying results (Nielsen Norman Group, October 2025).

Even the good outputs had recurring defects, which make a useful review checklist:

NN/g concluded the tools fit early-phase work best and that strong design knowledge is still needed to use them well. In practice: give the AI your job sentence, your flow and your style choices, not a one-line idea, and review every screen against the checklist above.

How do you write a good design prompt?

Worked Example: Designing a Run Logging App

Here is the whole process applied to one small app, so you can copy the structure.

This app has five main screens: Run, Active run, Summary, History and Settings. A version this size is a realistic first design project for one person.

How Much Does It Cost to Design an App?

Designing an app costs anywhere from nothing (you plus free tools) to tens of thousands of dollars (a professional designer or agency), and the biggest variable is whose time you pay for. Tool subscriptions are small next to labor.

To estimate a freelance budget, multiply the number of screens in your flow by the hours each needs, then by the rate. A simple app with a short flow is a few days of work; a complex app with many states and edge cases can take weeks. Designing in code also changes the math, because the design and the first build become one step rather than two. Our cheapest app builders comparison covers what building costs after design.

Example freelance budgets

The figures below are simple arithmetic on Upwork's published ranges, not quotes from any designer. They assume about four hours of design per screen, including revisions.

A Seven-Day Plan to Design Your First App

Numbers Worth Knowing Before You Start

Common App Design Mistakes

Most first app designs fail in the same few ways, and all of them are cheap to fix early and expensive later:

• Designing screens before the flow. You end up with beautiful screens that do not connect.
• Too many features in version one. Every extra feature adds screens, states and confusion. Ship the job sentence first.
• Custom controls for standard tasks. People already know how platform buttons, lists and tab bars behave.
• Tiny tap targets and low contrast. Below 44x44 pt on iPhone or 48x48 dp on Android, people miss taps.
• Ignoring empty, loading and error states. The first-run screen with no data is often the first thing a user sees.
• Asking for permissions at launch. Ask when the feature that needs the data is first used.
• Too many prominent buttons. One or two per screen; more makes every choice slower.
• Designing for one phone size. Check the smallest and largest screens, and large text sizes.
• Designing only in light mode. Dark mode is a different palette, not an inversion.
• Never testing with real people. A handful of short sessions usually surfaces the biggest problems.
• Treating the design as finished at handoff. Design intent gets lost between a static file and code unless someone checks the built app.

Frequently Asked Questions

How do I design an app with no experience?
Write one sentence describing what the app does and for whom, draw the steps a user takes on paper, then describe each screen to an AI tool such as Superapp for a working iPhone app or Banani for a design file. Follow Apple's or Google's published rules for tap targets, text size and contrast, and test with a few real people before you build.

What is the best tool to design an app?
Superapp is the best tool for designing directly in code, because it outputs native SwiftUI screens you can run and publish. Banani is the best pure design tool in 2026: it generates editable multi-screen designs and prototypes from prompts and exports to Figma. Figma remains the standard for teams with a professional designer.

Can I design an app for free?
Yes. Superapp's free starter credits, Banani's free plan (12 credits a month plus daily refills), Figma's free Starter plan and paper are enough to design and test a first version. Exports to Figma or code on Banani require a paid plan, and publishing on the App Store needs a $99 a year Apple Developer account.

How do I design an app for iPhone?
Start with Apple's patterns: tab bars, navigation stacks, sheets, the system font and system colors. Use 44x44 point tap targets, 17 point body text, 4.5:1 contrast for normal text, respect the safe area around the Dynamic Island, and test with large Dynamic Type sizes. Superapp generates these native SwiftUI components for you, and Apple's free iOS 27 UI Kit covers them for Figma and Sketch.

How do I design an app for iPad?
Treat iPad as its own layout. Lay out by size class rather than device, show an iPhone-style single column in narrow windows, and switch to a sidebar or list-plus-detail layout when the window is wide. Superapp builds iPad layouts tailored to the larger screen from the same project as the iPhone app.

How do I design an app for Android?
Use Google's Material Design patterns, 48x48 dp touch targets, sp units for text, window size classes for layout, and at least 4.5:1 contrast for text under 18 sp. Superapp builds Apple platforms, so for Android use Banani or Figma to design, then Android Studio with Kotlin and Jetpack Compose, or an Android developer, to build.

How much does it cost to design an app?
From $0 with free tools to tens of thousands of dollars with an agency. Superapp's Pro plan is $25 a month, Upwork lists median UI designer rates of $20 to $40 an hour, and the US Bureau of Labor Statistics reports a $104,000 median salary for web and digital interface designers in May 2025.

Can AI design my app?
AI can produce a usable first draft in minutes, especially from a detailed prompt, and Superapp turns that draft into a running app. Nielsen Norman Group found AI designs still tend to have weak hierarchy, poor grouping, overused colors, poor contrast and inconsistent spacing, so review every screen before you build or test it.

What is the difference between a wireframe, a mockup and a prototype?
A wireframe is a low-detail layout with grey boxes and no styling. A mockup is a static, styled version of a screen. A prototype is clickable or running, so people can move between screens and try the flow; Superapp's prototypes are the real app running in a simulator. Design in that order so you change cheap things first.

How long does it take to design an app?
A simple app with one core job and a short flow can be designed and tested in about a week, as in the seven-day plan above; a complex app with many states can take weeks. AI tools such as Superapp and Banani shorten the drawing time, but defining the job, mapping the flow and testing with people still take most of the effort.

Do I need to know how to code to design an app?
No. Design itself needs no code. To turn a design into an app without coding, you can use a tool that designs in code for you, such as Superapp for iPhone, iPad, Mac and Apple Watch apps, or hire a developer to build from your design file.

How many users do I need to test an app design?
About five per round. Jakob Nielsen's analysis found that a first test with five users uncovers most usability problems, so the better plan is several small rounds: test Superapp's simulator build or a Banani prototype with five people, fix the problems, then test with five new people.

What screens does every app need?
Beyond the core flow: a launch screen, optional onboarding, permission requests at the moment of need, loading states, empty states, error messages and settings. Superapp generates the app shell with standard components; designing each of these states deliberately is what makes an app feel finished.

How do I design an app icon?
Keep it simple: one idea, few shapes, no text unless it is essential. Apple's icon canvas is 1024x1024 px with layers assembled in Icon Composer and default, dark, clear and tinted variants; Google Play needs a 512x512 px PNG. Superapp includes a built-in app icon generator for apps you build with it.

Should my app support dark mode?
Yes. Apple asks apps to look good in both appearances and advises against an app-specific appearance setting. Use system colors where you can, check that contrast stays at or above 4.5:1, and preview Superapp or Banani screens in both modes before testing.

What is Liquid Glass and how does it affect app design?
Liquid Glass is Apple's material for controls and navigation that float above content. Apple says not to use it in the content layer and to apply it sparingly to custom controls. Standard components, like those Superapp generates in SwiftUI, adopt it automatically.

Is Figma still needed to design an app?
Not for a solo founder. Superapp designs in code, and Banani generates editable designs without Figma, though Banani can export to Figma when a team needs it. Figma remains the best fit for teams with a dedicated designer and a separate engineering handoff.

What is the best free app design tool?
For a running iPhone app, Superapp's free starter credits; for a design file, Banani's free plan with 12 credits a month plus daily refills; for hand-drawn designs, Figma's free Starter plan. Google Stitch, in beta, is worth trying for extra layout ideas.

How do I design an app that passes App Store review?
Design a real app experience rather than a website in a frame: Apple's guideline 4.2 asks for features, content and UI that go beyond a repackaged website. Build from native components, ask for permissions only when needed with a clear reason, and follow the Human Interface Guidelines. Superapp generates native SwiftUI, which helps, but Apple still reviews every app.

References

• Apple Human Interface Guidelines: Accessibility
• Apple Human Interface Guidelines: Layout
• Apple Human Interface Guidelines: Typography
• Apple Human Interface Guidelines: Color
• Apple Human Interface Guidelines: Dark Mode
• Apple Human Interface Guidelines: Materials
• Apple Human Interface Guidelines: Tab bars
• Apple Human Interface Guidelines: Sheets
• Apple Human Interface Guidelines: Buttons
• Apple Human Interface Guidelines: Writing
• Apple Human Interface Guidelines: Launching
• Apple Human Interface Guidelines: Onboarding
• Apple Human Interface Guidelines: Privacy
• Apple Human Interface Guidelines: Loading
• Apple Human Interface Guidelines: App icons
• Apple Design Resources
• App Store Review Guidelines
• App Store Connect: Screenshot specifications
• Android Developers: Make apps more accessible
• Android Developers: Window size classes
• Android Developers: Jetpack Compose
• Google Play icon design specifications
• W3C: Understanding WCAG 2.2 Target Size (Minimum)
• Nielsen Norman Group: AI Prototyping in Real Design Contexts
• Nielsen Norman Group: Why You Only Need to Test with 5 Users
• Nielsen Norman Group: 10 Usability Heuristics
• US Bureau of Labor Statistics: Web Developers and Digital Designers
• Upwork: UI designer cost
• Banani and Banani pricing
• Figma pricing and Figma Make
• Google Stitch
• Superapp, Superapp features, Superapp pricing and Figma to iOS app
• Related: Best mobile app prototyping tools, How to make an app, How to create an app