Overview
At ustwo, we take great pride in building better iOS experiences—ones that feel intuitive, seamless, and thoughtfully crafted. From smart integrations to small but impactful refinements, we focus on the details that enhance usability. These are the elements that create delightful surprises and make an app feel deeply integrated with the device.
Thoughtful iOS features like Dynamic Type, reduced motion, and system integrations don’t just add polish—they support a more inclusive experience. Many of these enhancements come almost for free when you design with the platform in mind. They align with our Inclusivity Principles, helping us craft apps that are intuitive, accessible, and feel truly native—all without adding significant overhead to the development process.
In this article, we share some of the techniques we use to achieve that balance—simple, effective ways to level up your iOS projects without overloading your roadmap.
Accessibility
Accessibility is one of our priorities (and mandated by the European Accessibility Act directive, starting in 2025) and while iOS offers many built-in tools, there’s always more we can do to support all users. At the very least, we focus on considering, utilizing, and testing these key features:
- VoiceOver (labels, hints, traits)
- Dynamic Text (minimum sizes and scaling)
- Color filters & inverted colors
- Increased contrast
- Reduced transparency
- Reduced animation
- Haptic feedback
- AssistiveTouch
Accessibility isn’t a "one-and-done" or tickbox exercise, it’s about always striving to do better.
Dynamic type support
Dynamic type allows users to adjust text size on their devices. Since iOS 15, developers have been able to set scaling limits, and we ensure our layouts adapt accordingly and are tested thoroughly to maintain a seamless experience. A useful tip is to use the ScaledMetric property wrapper to proportionally scale spacing, images, and other elements, keeping them consistent with the user’s text size preferences.
A side-by-side look at standard vs. enlarged text using Dynamic text.
App intents
The App Intents framework introduced in iOS 16, lets users interact with your app’s actions and content directly from outside the app—think Siri, widgets, or Control Center.
They’re a powerful tool that:
- Allow users to perform actions without opening the app.
- Integrate seamlessly with system features like Siri and Spotlight.
- Exposes an app’s functionality for broader accessibility.
- Provides clear descriptions of actions for better usability.
Personally, I feel Intents are one of the best tools to hit iOS in years. If you haven’t explored them yet, I highly recommend checking them out.
Home screen quick actions
Home Screen Quick Actions give users an easy way to access app-specific features right from the Home Screen. For example, in one of our recents projects Sproutiful, we added a quick action to access a core feature in just a tap.
Custom iOS home screen quick action example, providing a shortcut for core app functionality.
Making the most of context menus
Context Menus are a great way to present a menu of actions, along with an optional custom preview, using the ContextMenu modifier.
Here are some tips for using them effectively:
- Focus on the most useful actions and aim for no more than three options.
- Use submenus only when absolutely necessary.
- Place frequently used options where users will see them first, adjusting based on menu positioning.
- Put destructive actions like "Delete" at the end of the menu and highlight them in red where supported.
Context Menus help streamline functionality while keeping your app clean and intuitive!
Here’s an example of how they have been used within a messaging product.
An example of an iOS context menu, showcasing quick actions like replying in a thread, reporting, sharing, and copying text.
Optimizing for every device and screen size
These days, iOS devices come in a wide variety of sizes-from smaller iPhone SEs to iPad Pros. As developers we should have all of these in mind when developing. The amount of work required to make the most of these devices can vary but it’s important to do the best with the resources available to you, whether that be design resources, development time or testing capacity.
The most common issues we see are where people haven’t properly considered device rotation, the screen estate available and keyboard interactions. Much of this can be tested within the simulator so access to devices is not a valid excuse. Importantly, this impacts how users interpret the overall quality of an app’s development. Even a quick smoke test is better than nothing at all - you’ll probably be surprised what you discover.
Smarter loading strategies for a seamless experience
With faster connections and caching, preloaders are becoming less necessary. If you do use them, adding a small delay before showing them can avoid a quick flash, creating smoother transitions and reducing states for the user.
The redacted view modifier is a great alternative, showing loading statuses while hinting at what content to expect, making traditional preloaders less relevant. An example can be seen here...
Redacted UI elements example, providing a structured preview while content is being fetched.
Finally, carefully plan where and how your loading happens—group tasks or run them in the background to minimize interruptions to the user experience.
User-friendly error handling
Good error handling is key, but keeping users informed and offering options when things go wrong is just as important.
A simple dialog for no internet connection works, but adding helpful advice—like reconnecting steps or a prompt with a "Try Again" button—makes the experience much smoother and user-friendly.
Confirm critical actions
Always let users back out of potentially destructive actions like logging out, deleting, or clearing data. These actions can have a big impact if done by mistake, so use an action sheet or dialog to confirm before proceeding.
Confirmation dialog for account deletion, ensuring users can back out of potentially destructive actions.
Offline support
Offline support in your iOS app can range from basic data caching for viewing content offline to more advanced features like allowing tasks to sync when back online. Start by deciding what level of offline support would be most useful to your users as a bare minimum.
You can implement offline support in various ways, even as basic as using UserDefaults, local JSON files, or a local database to name a few. Each option has its own pros and cons, so it’s important to choose the best approach for you.
Consider startup time + general performance
Startup speed and overall performance are key to a great user experience. Slow load times or laggy UI can leave a bad impression, so it’s important to consider and potentially track rendering rates, responsiveness, and freezes to keep things smooth.
Simply testing a development version on-device in real-world situations is a great way to catch and improve performance issues early. Tracking and monitoring tools can help you monitor performance in the wild across devices and networks, providing insights to spot and fix issues.
It's important to profile any project. This is easily achievable with Instruments but also remember tools such as the Launch Time pane within Xcode Organizer and MetricKit.
Help users uncover new and existing features
iOS 17 introduced us to the TipKit framework - it’s a great way to introduce new users to features of your app they may not have discovered yet. In previous times we would have onboarding flows to show users app features but now there are many ways to add such functionality in a more seamless way.
A TipKit example, providing contextual feature guidance.
Make widgets, extensions and control center app extensions
There are many benefits to adding a widget or extension to your iOS app and often a widget can start off quite small with limited functionality that can be extended upon over time.
Widgets provide a modern, user-friendly experience that improves engagement, retention, and app value via:
- Boosting engagement by providing quick access to key information or action.
- Widgets oncreases visibility and keep your app front and centre, driving usage.
- Deliver personalized, real-time content, saving users time and improving convenience.
- Offers timely updates, reminders, or relevant insights, fostering regular interaction.
- Leverages iOS integration via the home and lock screen, offering context-aware visibility to stay relevant.
An example of an iOS home screen widget.
Integrate with spotlight
There are so many benefits to making your app's content and actions available to Spotlight - all of which can make your app more accessible, intuitive, and valuable to your users.
- Improved Discoverability: Help users find and access features and content from their device search bar.
- Enhanced User Engagement: Surface relevant actions or data, making it easier for users to re-engage with your app.
- Faster Access: Users can quickly jump to specific content or perform common actions without navigating into your app.
- Seamless User Experience: Making your app feel more connected to the system and providing a more intuitive experience.
- Personalized Suggestions: With Siri intelligence, Spotlight can surface your app’s content based on behavior, making your app more relevant in day-to-day use.
- Competitive Edge: Apps that integrate well with Spotlight feel more modern and user-friendly, helping you stand out in a crowded app ecosystem.
Support dark mode
Dark mode has been around since iOS 13—almost five years now. Even if we don’t always have a custom dark mode design for a project, we still make sure to test it as part of our QA process (both automatically via snapshot tests and manually by our QA team)
Supporting dark mode is easier than you might think, with plenty of tools available to help. And if needed, you can always temporarily disable it for a quick fix.
An example of dark mode vs. light mode within the same iOS app.
What next?
We’ve covered a range of practical ways to enhance iOS apps—whether it’s improving accessibility, optimizing performance, integrating system features, or refining the overall user experience. Small but thoughtful improvements can make a big difference, helping an app feel seamless, intuitive, and at home on iOS.
The best apps don’t just work—they feel like they were made by someone who cares. By focusing on the little details, we’re not just improving functionality; we’re creating experiences that feel effortless, considered, and genuinely helpful to the people using them.
Want to go deeper on how inclusive thinking shapes our mobile work at ustwo? Check out this piece on how we apply our Inclusivity Principles to create breakthrough experiences for all.
Now, it’s time to put these ideas into action. Start small, test often, and keep refining—because the best user experiences are built through continuous iteration.