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

Superapp lets you design an app directly in working code, and Banani is the best pure AI design tool. This guide covers the eight-step process, the platform rules Apple and Google publish, every screen an app needs, and what design 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.

StageWhat you decideOutputBest tool for it
1. JobThe one problem the app solvesOne sentenceSuperapp chat, or a notes app
2. FlowThe steps from opening the app to finishing the jobA flow diagramSuperapp, paper, FigJam
3. WireframeLayout of each screen, no stylingGrey boxes per screenSuperapp, Banani, paper
4. Tool choicePure design file or design in codeA decisionSee the tool table below
5. Platform rulesTap targets, text sizes, navigation patternsA checklistApple HIG, Android docs
6. Visual designType, color, icons, spacingStyled screensSuperapp, Banani, Figma
7. Prototype and testWhether real people can finish the jobA list of fixesSuperapp simulator, Banani prototypes
8. BuildThe working appAn installable appSuperapp, Xcode, Android Studio

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.

TermWhat it meansWhere you see it
Design in codeDesigning by generating real, running screens instead of pictures of screensSuperapp, which outputs SwiftUI
User flowThe sequence of steps a person takes to finish a taskStep 2 of this guide
WireframeA low-detail layout of one screen, grey boxes and no stylingPaper, Banani, Superapp
MockupA static, styled picture of a screenBanani, Figma
PrototypeA clickable or running version people can move throughBanani, Figma, Superapp simulator
Design systemThe shared set of fonts, colors, spacing and componentsSuperapp's built-in design system, Figma libraries
Design tokensNamed values for colors, type and spacing, such as "accent" or "spacing-8"Banani token editing, Superapp design system
Point (pt)Apple's layout unit, independent of screen pixelsApple HIG
Density-independent pixel (dp)Android's layout unit; sp is the same idea for textAndroid docs
Safe areaThe part of the screen not covered by the Dynamic Island, home indicator or barsApple HIG, Layout
Size classApple's compact or regular label for available width and heightiPad and resizable windows
Window size classAndroid's width breakpoints, such as compact under 600dpAndroid adaptive layouts
Dynamic TypeiOS setting that lets people choose their text sizeApple HIG, Typography
Liquid GlassApple's material for controls and navigation that floats above contentCurrent Apple platform designs
SF SymbolsApple's library of icons that match the system fontApple Design Resources

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.

Weak job sentenceStrong job sentenceWhy the strong one designs better
"An all-in-one fitness app""Runners log a run in under ten seconds" (a sentence you can paste straight into Superapp)One main screen, one main button, an obvious test
"A better way to manage money""Freelancers send an invoice before the client call ends"Defines the core form and the time limit
"An app for parents""New parents log a feed with one hand"Forces large targets and a one-tap flow
"A social app for book lovers""Readers share one quote from the page they are on"Defines the camera or text-entry screen as the core

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:

Flow pieceQuestion to answerExample (run logging app)
Entry (in Superapp, describe this first)Where does the user start?Home screen with a big Start button
Core actionWhat is the one main thing they do?Tap Start, run, tap Stop
ConfirmationHow do they know it worked?Summary card with distance and time
First-run branchWhat changes on the very first open?Ask for location permission with a reason
Error branchWhat happens when something fails?GPS lost: keep timing, show a warning
Return visitWhat do they see the second time?Last run plus the Start button

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.

Flow shapeiPhone patternAndroid patternRule to remember
Superapp default for a multi-section appTab bar with native SwiftUI tabsNot applicable (Apple platforms)Superapp generates the standard pattern, so it behaves as people expect
A few top-level sections people switch betweenTab barNavigation barApple: "Use a tab bar to support navigation, not to provide actions."
Drilling into details (list to item)Navigation stack with a Back buttonTop app bar with UpKeep the path reversible at every step
A short, self-contained taskSheetBottom sheet or dialogApple: "Display only one sheet at a time from the main interface."
Many sections or a complex hierarchyTab bar that adapts to a sidebar on iPadNavigation rail or drawer on larger screensSwitch patterns by available width, not device
One main action on a screenProminent buttonFloating action buttonApple: "Keep the number of prominent buttons to one or two per view."

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.

Wireframe methodSpeed for 5 layoutsFidelityBest when
Superapp promptMinutes, each one runsRunning native screenYou want to feel the layout on a simulated iPhone right away
Banani promptMinutes, editableStyled, editable designYou want variations to compare or hand to someone
Paper and penAbout ten minutesRough sketchYou are still unsure what the screen is for
Figma framesSlower, by handExactly what you drawYou have a designer or design skills

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.

ToolBest forWhat you getExportsStarting price
SuperappDesigning in code, iPhone, iPad, Mac and Watch appsNative SwiftUI screens running in an iOS simulatorFull Xcode project, App Store publishingFree starter credits; Pro $25/month
BananiPure AI UI design for mobile and webEditable multi-screen designs and clickable prototypesFigma, HTML/CSS (paid plans)Free (12 credits a month); Plus $20/month
FigmaHand-crafted design and team handoffDesign files, prototypes; Figma Make for AIDesign specs, Dev ModeFree Starter; Professional $16/month per Full seat
Google StitchAI UI ideas from GoogleMobile and web UI draftsCheck current optionsBeta
Paper and penFast early wireframesSketchesA photoFree

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?

You arePickWhy
A founder with an iPhone app idea and no developerSuperappThe design is the working app, and it can be published
A designer delivering screens to a clientBananiFast, editable designs that export to Figma
A product team with a designer and engineersFigma, plus Banani for explorationShared files, specs and handoff
An Android-first founderBanani or Figma, then an Android developerDesign tools work for any platform
A student learning app designPaper, then Banani's free planLearn the process before paying
A business owner who wants an app and a websiteSuperappIt builds native Apple apps and websites

Pick it or skip it

ToolPick it whenSkip it when
SuperappYou want the design to run on a simulated iPhone today and publish laterYou need Android from the same project
BananiYou want the best AI-generated design fileYou need a finished app without a build step
FigmaA designer will own the design long termYou are a solo beginner on a deadline
Google StitchYou want a second opinion on layouts from GoogleYou need confirmed export options
PaperYou are still working out the flowYou need something to show users on a phone

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.

RuleiPhone and iPad (Apple HIG)Android (Google)
How Superapp applies theseGenerates standard SwiftUI controls and system text stylesNot applicable (Apple platforms)
Tap target44x44 pt default, 28x28 pt minimumAt least 48x48 dp
Space between controlsAbout 12 pt around bezeled controls, about 24 pt around borderless onesLarger targets preferred
Body text17 pt default, 11 pt minimumUse scalable sp units
Contrast, normal text4.5:1 for text up to 17 pt4.5:1 for text under 18 sp
Contrast, large or bold text3:13:1
Text scalingSupport enlarging text by at least 200 percentSupport user font size settings
Color aloneNever the only signal; add shapes or iconsSame principle

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.

iOS text styleDefault size (pt)Default leading (pt)Typical use
Superapp outputSystem text stylesSystem leadingGenerated SwiftUI uses the platform styles
Large Title3441Top of a main screen
Title 12834Section headers
Title 22228Sub-section headers
Title 32025Card titles
Headline17 (semibold)22List row titles
Body1722Main reading text
Callout1621Short supporting text
Subhead1520Secondary labels
Footnote1318Small print
Caption 11216Image captions
Caption 21113The smallest standard text

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.

DecisionSafe default for a first appWhy
Where to set it in SuperappThe built-in design systemOne change applies to every screen
FontThe system font (SF Pro on Apple, Roboto on Android)Built for legibility and scales with user settings
Text sizesUse the platform's text styles, not fixed sizesThey scale with Dynamic Type
ColorsOne accent color plus system colorsSystem colors adapt to dark mode and Increase Contrast
IconsSF Symbols on Apple platformsOver 7,000 symbols that match the system font
SpacingOne base unit (for example 8 pt) and multiples of itConsistent rhythm reads as polish
ControlsStandard buttons, lists, tab barsPeople already know how they behave

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

Color ruleWhat it means in practice
Superapp's design system holds the paletteSet the accent once and generated screens reuse it
One meaning per colorAccent means "tappable"; red means "destructive"
Prefer system colorsThey adapt to light, dark and Increase Contrast automatically
Supply light and dark variants for custom colorsApple asks for both even if you ship one appearance
Never rely on color aloneAdd an icon, label or shape for status
Check cultureApple notes red means danger in some places and positive change in others
Test outdoors and in dim lightColors look darker in sunlight and more saturated in the dark

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

Liquid Glass decisionApple's guidance
Superapp outputUses standard SwiftUI components, which take on the system material
Where to use itControls and navigation that float above content
Where not to use itApp backgrounds and other content-layer elements
Custom controlsApply it sparingly, only to the most important functional elements
Clear variantOnly over visually rich backgrounds such as photos and video
DimmingOver bright content, consider a dark dimming layer at 35 percent opacity
Color on glassReserve tint for primary actions and status, not every control

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

Dark mode checkTarget
Superapp screensPreview the simulator in both appearances before you test
Minimum contrastNo lower than 4.5:1
Custom colors, especially small textAim for 7:1
Images with white backgroundsDarken slightly so they do not glow
IconsUse SF Symbols, which adapt automatically
BackgroundsPrefer system backgrounds so sheets and popovers look elevated

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.

Text elementWeakStrong
Superapp prompt for copy"Make the text nicer""Use verbs on every button and sentence case for headings"
Button"Let's go!""Log run"
Error"Something went wrong""Couldn't save your run. Check your connection and tap Retry."
Password error"Too short""Use 12 or more characters"
Empty state"No items""No runs yet. Tap Start to log your first one."
Multi-step flowA different button word on every stepThe same word on every step, and a clear finish word on the last
Settings labelA long sentenceA short label plus a one-line explanation

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.

Test questionWhat to watchCommon fix
Can they find the core action in the Superapp simulator?Where their eyes and thumb go firstAsk Superapp to make the main button bigger and higher
Do they understand labels?Hesitation, reading twiceReplace jargon with verbs ("Log run")
Can they recover from mistakes?What happens after a wrong tapAdd undo or a clear Back
Do they know it worked?Whether they look for confirmationAdd a visible success state
Can they read everything?Squinting, zoomingRaise text size or contrast

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.

HeuristicQuestion to ask of each screen
Visibility of system status (check the Superapp simulator's loading states)Does the person always know what is happening?
Match between the system and the real worldDo words match the user's language, not internal jargon?
User control and freedomIs there a clear way back or undo?
Consistency and standardsDo controls look and behave like platform controls?
Error preventionDoes the design stop mistakes before they happen?
Recognition rather than recallAre options visible instead of memorized?
Flexibility and efficiency of useCan repeat users go faster?
Aesthetic and minimalist designIs anything on screen not needed for the task?
Help users recognize, diagnose, and recover from errorsDo errors say what went wrong and how to fix it?
Help and documentationIs help easy to find for the few who need it?

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.

ScreenRule from Apple's guidelinesWhat to design
Superapp's generated app shellBuilt from standard SwiftUI componentsReview each screen below inside the simulator
Launch screen"Design a launch screen that's nearly identical to the first screen of your app"A plain version of your first screen, no logo or text
OnboardingDesign a flow that's "fast, fun, and optional"Teach by doing, or skip onboarding entirely
Permission request"Request access only to data that you actually need."Ask when the feature is first used, with a clear reason
Loading"Show something as soon as possible."Placeholders, then real content
Empty stateGive clear next steps on blank screensOne sentence plus a button to start
ErrorShow the error near the problem, without blameWhat happened and how to fix it
SettingsShort labels, with an explanation if neededOnly settings people actually change

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

Icon specApple (iOS, iPadOS, macOS)Google Play
Superapp workflowSuperapp has a built-in app icon generator for the app you buildNot applicable
Canvas size1024x1024 px, layered512x512 px
FormatLayers, ideally vector, assembled in Icon Composer32-bit PNG, sRGB, up to 1024 KB
CornersProvide square layers; the system masks the shapeFull square; Play applies the rounded mask
AppearancesDefault, dark, clear and tinted variantsOne icon
TextOnly when essential to the brandAvoid where possible
EffectsLet the system add highlights and shadowsPlay adds the drop shadow

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.

Screenshot speciPhone 6.9-inchiPad 13-inch
How Superapp handles itSuperapp prepares App Store screenshots as part of publishingSame, when the app runs on iPad
Accepted portrait sizes1260x2736, 1290x2796 or 1320x2868 px2064x2752 or 2048x2732 px
Number allowed1 to 101 to 10
Required?No; scaled screenshots from another iPhone size can be usedYes, if the app runs on iPad
FormatJPEG or PNG, no transparencyJPEG or PNG, no transparency

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

RouteWho it suitsMain costMain risk
Superapp: design in codeFounders without a developer, iPhone and iPad appsSubscription creditsApple platforms only
Banani or Figma, then a developerTeams with budget, Android or cross-platform appsDeveloper timeDesign intent lost in handoff
Design, then build it yourself in Xcode or Android StudioPeople willing to learn Swift or KotlinMonths of learningSlow first version

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?

Step in SuperappWhat you doWhat you get
1. Describe the job in SuperappPaste your job sentence and the happy-path flowA first running version of the core screen
2. Set the design systemChoose typography, accent color, spacing and component styleEvery later screen follows the same tokens
3. Add screens one at a timeDescribe each flow step, or paste a Figma frame linkNative SwiftUI screens with working navigation
4. Check in the simulatorTap through the flow, try large text and dark modeProblems a static mockup would hide
5. Fix by chatDescribe what to change ("move Start higher, make it larger")The agent edits, compiles and rebuilds
6. Test with peopleRun the five-person test on the simulator buildA short list of fixes
7. PublishConnect an Apple Developer accountBuild, screenshots, metadata and submission prepared

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

Step in BananiWhat you doWhat you get
1. PromptDescribe the app, or upload a PRD, screenshot or Figma linkA first multi-screen design you can later export to Figma and paste into Superapp
2. RestyleAsk for a style direction, or edit tokens by handA consistent visual direction
3. PrototypeGenerate the clickable flowA shareable prototype
4. ShareSend a link for commentsFeedback from teammates or clients
5. ExportExport to Figma or HTML/CSS on a paid planA file for a developer, or for Superapp's Figma import

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.

Handoff itemWhy it matters
Superapp project or Xcode export, if you designed in codeThe developer starts from running code instead of pictures
The job sentence and the flow diagramThe developer understands what matters most
Every screen, including empty, loading and error statesMissing states get improvised
Design tokens: colors, text styles, spacingKeeps the build consistent
Light and dark versionsDark mode is not an automatic inversion
Large text versions of key screensLayouts break at large Dynamic Type sizes
Icon and image assets at the right sizesAvoids blurry or cropped assets
Notes on gestures and animationsStatic files cannot show motion

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

WidthTypical iPad layout
Superapp iPad outputLayouts tailored to the larger screen, from the same project as the iPhone app
Compact (narrow window)iPhone-style single column with a tab bar
Regular (wide window)Sidebar plus content, or list plus detail

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

Android width classBreakpointTypical layout
Superapp equivalentApple size classes (compact and regular)Superapp builds Apple platforms; use Banani or Figma for Android screens
CompactUnder 600dpSingle column, bottom navigation bar
Medium600dp to under 840dpNavigation rail, wider content
Expanded840dp to under 1200dpList plus detail
Large1200dp to under 1600dpMulti-pane
Extra-large1600dp and upMulti-pane with more room for content

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:

Defect NN/g found in AI designsWhat to check in your design
Weak visual hierarchy (Superapp: ask it to enlarge the core action)Is the core action the most prominent thing on screen?
Poor grouping of related itemsAre related fields and buttons visually together?
Overused colorsIs color reserved for meaning, not decoration?
Poor contrastDoes text meet 4.5:1?
Inconsistent marginsIs spacing based on one unit?
Generic, interchangeable styleDoes anything reflect your brand?
Wrong pattern for the taskDoes the layout fit your job sentence, not a generic template?

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?

Prompt partWeakStrong
Superapp prompt opener"Make a running app""iPhone app for runners to log a run in under ten seconds"
Screen"A home screen""Home: large Start button centered low, last run card above it"
Style"Make it modern""System font, one orange accent, 8 pt spacing, dark mode supported"
States(missing)"Include empty state for no runs and a GPS-lost warning"
Constraints(missing)"44x44 pt minimum targets, 4.5:1 contrast"

Worked Example: Designing a Run Logging App

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

Design decisionChoice for the example app
ToolSuperapp, because the target is iPhone and the founder has no developer
Job sentenceRunners log a run in under ten seconds
FlowOpen, tap Start, run, tap Stop, see summary
NavigationTab bar with two tabs: Run and History
Core screenOne large Start button, last run card above it
First-run branchLocation permission asked when Start is first tapped, with a specific purpose string
Empty state"No runs yet. Tap Start to log your first one."
Error stateGPS lost: keep timing, show a warning banner
TypeSystem text styles: Large Title for the screen, Body for details
ColorOne accent color for Start and links only; red only for Delete
IconsSF Symbols for both tabs, with single-word labels
TestFive runners asked to "log the run you just finished"

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.

RouteTypical costSource
Design in code with SuperappFree starter credits, then $25 a month for ProSuperapp pricing
Do it yourself with free tiers$0 (Banani free, Figma Starter, Superapp starter credits)Vendor pricing pages
Do it yourself with paid AI toolsAbout $16 to $50 a month per toolFigma, Banani, Superapp pricing
Freelance UI designerMedian $20 to $40 an hour; US intermediate layout and design work $30 to $125 an hourUpwork
In-house designerMedian $104,000 a year for web and digital interface designers (US, May 2025)US Bureau of Labor Statistics
Publishing on the App Store$99 a year Apple Developer ProgramApple

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.

App sizeScreensHours (about 4 per screen)At $30/hourAt $125/hour
Superapp comparisonAnyYour own time$25/month Pro plan$25/month Pro plan
Small (one core flow)832$960$4,000
Medium (a few flows, accounts)2080$2,400$10,000
Large (many flows and states)40160$4,800$20,000

A Seven-Day Plan to Design Your First App

DayTaskOutput
Day 1Write the job sentence and open a Superapp or Banani projectOne sentence and a first generated screen
Day 2Map the happy path and branchesA flow diagram
Day 3Wireframe every flow stepRough screens
Day 4Apply platform rules and set design tokensConsistent, accessible screens
Day 5Design supporting screens: launch, empty, loading, error, permissionA complete set
Day 6Prototype and run the five-person testA list of fixes
Day 7Fix the repeated problems and review with the ten heuristicsA design ready to build or publish

Numbers Worth Knowing Before You Start

NumberWhat it isSource
About 1 credit per screenSuperapp's cost to convert a Figma frameSuperapp
44x44 ptApple's default control size on iPhone and iPadApple HIG
28x28 ptApple's minimum control sizeApple HIG
48x48 dpGoogle's recommended touch targetAndroid Developers
24x24 CSS pxWCAG 2.2 Level AA target minimumW3C
17 ptiOS default body textApple HIG
11 ptiOS minimum text sizeApple HIG
200 percentHow far Apple asks you to let people enlarge textApple HIG
4.5:1Minimum contrast for normal textApple HIG
7:1Apple's target for custom colors in small textApple HIG
1024x1024 pxApple app icon canvasApple HIG
512x512 pxGoogle Play icon sizeGoogle Play
1 to 10App Store screenshots per device sizeApp Store Connect
600dpAndroid's compact to medium width breakpointAndroid Developers
7,000+Symbols in SF Symbols 27Apple Design Resources
5Users per small usability test, per Jakob NielsenNN/g
$104,000US median pay, web and digital interface designers, May 2025BLS
$99 a yearApple Developer ProgramApple

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.
MistakeHow to spot itFix
Static design that never shipsMonths of mockups, no running appDesign in code with Superapp, or set a build date
Flow too longMore than four taps to the core actionCut or merge steps
Hidden navigationTesters ask "how do I get back?"Use a visible tab bar or Back
Unreadable textTesters zoom or squintSystem text styles, 4.5:1 contrast
Permission deniedLow opt-in in testingAsk in context with a specific purpose string
Blank screensTesters think the app is brokenPlaceholders, empty states with a next step

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

Superapp LogoSuperapp

Build iOS or web apps with AI

Superapp is AI that builds your iOS or web app and runs your marketing while you sleep.

Build an app

Already have an app? Superapp can get you users with Marketing AI. Learn more