UUS Practice Tests⌕ Search
IT Certifications · 70-357

Exam 70-357: Developing Mobile Apps Practice Test

Exam 70-357: Developing Mobile Apps covers software development decisions for mobile applications, from responsive interfaces to local data and network-dependent behavior. The available practice material touches on Xamarin.Forms interactions, offline caching, push notifications, storage choices, accessibility, and app security. These scenarios connect implementation choices to practical needs such as keeping forms usable across orientations and protecting user-generated content.

Exam overview

Exam providerMicrosoft
Exam code70-357
CategoryIT Certifications

About the Exam 70-357: Developing Mobile Apps Exam

Mobile development work requires coordinating the user interface with device capabilities and remote services. Practice scenarios address binding a Xamarin.Forms control to application logic, adapting layouts when orientation changes, and supporting larger accessibility text without making controls unreachable. Other examples involve choosing storage for reproducible files, refreshing cached server data after connectivity returns, and handling concurrent edits when a server rejects a locally updated record. Security and reliability decisions include safely rendering user input, evaluating third-party image-decoding libraries for production, and selecting a notification mechanism for delivery when an app is inactive. A business-rule calculation, such as a cart discount, can be tested independently of the device interface and network with a unit test. These tasks reflect the practical judgment involved in building mobile apps that remain usable, secure, and consistent across changing device and connectivity conditions.

Sample Practice Questions

Review a selection from this exam's published US Practice Tests practice bank.

Question 1

A mobile app caches a server response to support offline use. What should it do when connectivity returns and cached data may be stale?

  1. ATreat cached data as permanently authoritative
  2. BApply an explicit synchronization or refresh policy with the server
  3. CDelete the app's executable files
  4. DDisable all future network access
Show answerCorrect answer: B

Offline caching requires a strategy for reconciling local and server state, such as refreshing data or resolving conflicts according to the app's rules. Cached data should not be assumed to remain current indefinitely.

Question 2

A mobile app stores a locally generated file that can be recreated by downloading it again. The device is running low on storage. Where is this file most appropriately kept?

  1. AIn an app cache or other storage location designated for regenerable data
  2. BIn a location reserved for user documents that the app must preserve permanently
  3. COnly in the app's executable installation bundle
  4. DIn a preference setting as a long encoded string
Show answerCorrect answer: A

Regenerable data is a good fit for cache storage, which the platform or app can clear when space is needed. Important user-created data should instead be stored in a more durable location with appropriate backup and retention behavior.

Question 3

A mobile app uses a third-party library to decode images. What is a good practice when selecting the library for a production app?

  1. AChoose any library with the largest number of downloads, without checking its maintenance status
  2. BReview its license, maintenance activity, platform compatibility, security posture, and required permissions
  3. CCopy its source into the app and remove all attribution requirements
  4. DAssume that a popular library cannot introduce vulnerabilities
Show answerCorrect answer: B

Dependency selection should consider legal, compatibility, maintenance, and security factors. Popularity alone does not guarantee that a package is safe, supported, or suitable for the app's requirements.

Question 4

A mobile app displays a user-generated comment that may contain markup-like characters. Which approach best avoids interpreting that content as executable or unintended markup?

  1. ARender it as text using the framework's text-binding mechanisms rather than constructing markup from the raw value
  2. BConcatenate it into a markup string and load that string as a page
  3. CRemove all spaces before displaying it
  4. DAssume content from another user is always safe
Show answerCorrect answer: A

Rendering untrusted content through a text API treats it as data instead of markup. Building UI markup from raw user input risks unintended interpretation and injection-like behavior.

Question 5

A mobile app supports portrait and landscape orientations. A screen contains a form whose controls must remain reachable in both orientations. Which implementation choice is most appropriate?

  1. APlace the entire form in a scrollable container and allow the layout to reflow
  2. BSet every control to a fixed screen coordinate
  3. CHide the last half of the form in landscape mode
  4. DAssume that the device will always launch in portrait orientation
Show answerCorrect answer: A

A scrollable, adaptable layout keeps controls accessible when the available vertical space changes. Fixed coordinates and assumptions about a single orientation are brittle across rotation and device sizes.

Question 6

A mobile app should receive a notification even when it is not actively open. Which mechanism is generally intended for this use?

  1. AA push notification service integrated with the platform
  2. BA timer that runs continuously in the foreground
  3. CA screen animation loop
  4. DA local variable retained only while a page is visible
Show answerCorrect answer: A

Platform push notification services can deliver notifications to an app that is not currently active, subject to user settings and platform delivery policies. A continuously running foreground loop is not a reliable or battery-friendly substitute.

Question 7

In a Xamarin.Forms app, a developer wants a visual control to invoke logic when the user taps it. Which approach best separates the UI interaction from the page’s code-behind?

  1. ABind the control’s Command property to an ICommand exposed by the view model
  2. BPlace all interaction logic in the control’s Style setter
  3. CUse a resource dictionary as the event handler
  4. DSet the control’s BindingContext to the application manifest
Show answerCorrect answer: A

Command binding lets a view model expose an ICommand that the UI can invoke, supporting separation of presentation and interaction logic. Styles and resource dictionaries describe reusable UI configuration, not event-handling behavior.

How to use this practice test

The free practice bank contains 50 questions; each session presents up to 20 selected at random. Complete a session to see your results, then use missed or uncertain items to identify which implementation decisions need closer review.

Preparation tips

  • Trace how an app should reconcile cached data after connectivity returns, and distinguish stale reads from server-side conflicts caused by concurrent edits.
  • Compare local storage choices for durable user data versus files that can be regenerated, including the impact of low device storage.
  • For Xamarin.Forms interface scenarios, consider command or binding patterns, orientation-responsive layouts, and whether controls remain usable with larger accessibility text.
  • Review mobile security choices for untrusted user-generated text and third-party libraries, including safe rendering and production maintenance considerations.
  • Separate business-rule tests from UI and network dependencies; identify when a unit test can verify calculations such as a cart discount.
Official sourceOfficial exam page ↗