Support phones and tablets from setup to sync

Three phone tickets reach the service desk before ten in the morning: a new hire’s iPhone shows no work mail although her password is right, a manager’s laptop cannot see his phone’s hotspot, and a tablet refuses an update with 0.7 GB available. Each one closes in minutes once you know the setting behind it, and each one can cost the user data if the steps come in the wrong order.

You will set up work email and connectivity the way the vendors document them, fix apps and storage with the cheapest safe step first, and recognise the faults that belong in a repair shop rather than in a settings menu.

Work email fails when the phone sends a bare password

The new hire added her mailbox in the iPhone’s Mail app with Configure Manually. Apple’s setup page says what that choice means: the account uses Basic authentication, so the phone sends the user name and password straight to the mail server. Microsoft has turned Basic authentication off in every Exchange Online tenant, for Exchange ActiveSync, POP, IMAP and Exchange Web Services alike, so the account fails however carefully she types.

The account works when it is added the other way. In Settings > Apps > Mail > Mail Accounts > Add Account > Microsoft Exchange, the Sign In button discovers the account, and an account that uses modern authentication is then guided through the organisation’s own sign-in steps, run by an identity providerThe service that checks who a user is and gives apps a token instead of their password; for Microsoft 365 it is Microsoft Entra ID.. That path is modern authenticationmodern authentication: Signing in to a service with short-lived tokens from an identity provider, using OAuth 2.0, instead of sending the user name and password to the service itself. It also lets an organisation ask for a second factor.: Microsoft describes it as OAuth 2.0 tokens with a limited lifetime that work only for the app and the service they were issued for.

Step through both paths and watch where the password goes in each:

In the first two steps the password travels to the mail server and is refused. In the Sign In path it only ever reaches the identity provider, which is also where a second factor such as an authenticator prompt is asked for.

Microsoft recommends Outlook for iOS and Android because it also supports the organisation’s access and app protection policies. A third-party app that reads mail over IMAP still works when it signs in with OAuth 2.0.

The rule is not special to Apple. Microsoft’s advice for any current mail app that still uses Basic authentication is the same: remove the account from the device, then add it back so that it signs in with modern authentication.

Most hotspot faults are a switch, a plan or a setting

A phone connects in three layers that fail on their own: Wi-Fi joins a network, cellular data runs over a SIM or an eSIMeSIM: A SIM built into a phone. The carrier activates it over the air or with a QR code, so a number moves to a new phone by a transfer instead of a card swap. linked to a carrier plan, and a hotspotmobile hotspot: A feature that shares a phone's cellular data connection over Wi-Fi, USB or Bluetooth, turning the phone into a portable access point for laptops and tablets. shares that cellular data with other devices over Wi-Fi, USB or Bluetooth. The manager’s laptop sees every network in the office except his phone, so the fault sits in the top layer, on the phone that shares.

Apple’s support page gives an order of checks, cheapest first, and Google’s page adds the Android limits. Step through the checks for the manager’s phone and note which one would erase something:

The first two checks cost nothing and settle most of these tickets: the hotspot must be on with Allow Others to Join, and the carrier must have enabled it on the plan. Only the fifth step has a price, because Reset Network Settings also removes every saved Wi-Fi network and password and the VPN and APN settings. Two limits from Google’s page save a wasted hour on Android: one phone shares its Wi-Fi hotspot with at most 10 devices, and a Mac cannot tether to an Android phone over USB.

Moving an eSIM: record the carrier and plan first

An eSIM is a SIM built into the phone, so moving a number to a new phone is a transfer rather than a card swap. Apple’s eSIM Quick Transfer needs both iPhones signed in to the same Apple Account, the old one opened with its passcode, both nearby with Bluetooth on and both on iOS 18.4 or later. When the plan activates on the new phone, the old SIM stops working.

With a carrier that does not support Quick Transfer, the move goes through the carrier’s own web page or a QR code that only the carrier can issue. Write down the carrier and the plan before you touch the eSIM, and make a test call from the new phone before anyone erases the old one.

Fix an app with the cheapest step that works

A finance app crashes the moment it opens, a day after the user updated the phone. Five fixes are on offer, and they differ in what they cost the user: some take seconds and lose nothing, the last one can lose work that never synced. Climb the ladder one rung at a time and test the app after each rung:

Rungs one to four keep everything the user has saved. Clearing the cache on Android deletes temporary data, so the app may open slowly once. Offloading an app on an iPhone removes the app but keeps its documents and data, ready for the reinstall. Only the last rung, deleting the app, removes its local data as well.

Updates cut both ways, which is why rung three is the operating system as well as the app. Apple’s security releases page lists iOS 27.0.1 and also iOS 26.7.1, so a phone that stays on iOS 26 still gets fixes; developer.android.com lists Android 17 as the newest release.

When the store will not install anything

Google Play Help lists the checks for downloads that stick or fail. A connection that drops, less than 1 GB of available storage, an old Android version and a stuck Play Store app are the usual causes. One check surprises people: the date and time. If Set time automatically or the automatic time zone is off, turn both on, wait a few minutes and try again.

Find what fills the storage before you delete anything

The tablet that refuses its update has 0.7 GB available out of 64 GB. Deleting the biggest thing in the list would make room at once, and it could also delete the only copy of a family video. The storage view shows what fills the device: on an iPhone or iPad it is Settings > General > [device] Storage, and on Android it is Settings > Storage, worded a little differently by each maker.

The program below sorts the sample tablet’s 63.3 GB into three piles: space that can go now without losing anything, space that needs a backup first, and space only the user can decide about. Run it and compare the piles:

# Sorts a tablet's storage into what can be cleared without losing anything, what needs a backup first and what
# only the user can decide. The storage figures are a sample for this lesson, not a real device's report.

CAPACITY_MB = 64_000  # a 64 GB tablet
LOW_MB = 1_000  # Google Play Help: less than 1 GB available can stop downloads and installs

# name, megabytes, what clearing it does to the user's data
ITEMS = [
    ("System", 11_000, "fixed"),
    ("Other apps and their data", 14_000, "fixed"),
    ("Videos backed up to Google Photos", 14_600, "keeps"),
    ("Videos that are not backed up", 6_300, "backup"),
    ("Chat photos and voice notes", 5_200, "backup"),
    ("Films downloaded for offline use", 4_100, "keeps"),
    ("Apps not opened in months", 3_800, "keeps"),
    ("Downloads folder", 2_400, "ask"),
    ("App caches", 1_900, "keeps"),
]

ACTION = {
    "fixed": "leave it",
    "keeps": "clear now",
    "backup": "back up first",
    "ask": "ask the user",
}


def gb(mb):
    return f"{mb / 1000:.1f} GB"


used = sum(mb for _, mb, _ in ITEMS)
available = CAPACITY_MB - used
print(f"Used {gb(used)} of {gb(CAPACITY_MB)}, available {gb(available)}")
if available < LOW_MB:
    print("Below 1 GB: downloads and updates can fail")
print()

for name, mb, kind in sorted(ITEMS, key=lambda item: item[1], reverse=True):
    print(f"{mb / 1000:5.1f} GB  {name}")
    print(f"          -> {ACTION[kind]}")
print()

totals = {kind: sum(mb for _, mb, k in ITEMS if k == kind) for kind in ACTION}
print(f"Clear now, nothing lost:  {gb(totals['keeps'])}")
print(f"Back up first:            {gb(totals['backup'])}")
print(f"Ask the user:             {gb(totals['ask'])}")
print(f"Available after clearing: {gb(available + totals['keeps'])}")

Used 63.3 GB of 64.0 GB, available 0.7 GB
Below 1 GB: downloads and updates can fail

 14.6 GB  Videos backed up to Google Photos
          -> clear now
 14.0 GB  Other apps and their data
          -> leave it
 11.0 GB  System
          -> leave it
  6.3 GB  Videos that are not backed up
          -> back up first
  5.2 GB  Chat photos and voice notes
          -> back up first
  4.1 GB  Films downloaded for offline use
          -> clear now
  3.8 GB  Apps not opened in months
          -> clear now
  2.4 GB  Downloads folder
          -> ask the user
  1.9 GB  App caches
          -> clear now

Clear now, nothing lost:  24.4 GB
Back up first:            11.5 GB
Ask the user:             2.4 GB
Available after clearing: 25.1 GB

24.4 GB can go at once: the videos already in Google Photos, the offline films, the unused apps and the caches. That lifts the tablet from 0.7 GB to 25.1 GB available without touching anything that exists only on the device. The 11.5 GB of videos and chat media that are not backed up wait until a backup has finished.

Sync that never finishes

iCloud Backup runs by itself when the iPhone is connected to power and to Wi-Fi and its screen is locked, and it needs enough iCloud storage to finish. An Android backup to Google One can take up to 24 hours, so a backup that shows as running in the afternoon may simply not be done yet. Check those conditions before you look for a fault.

Some faults need a repair shop, not a restart

A phone whose screen has lifted away from its frame is not a settings problem, and every minute spent on settings keeps a damaged battery in someone’s pocket. A lithium-ion batterylithium-ion cell: A rechargeable cell used in laptops, phones and newer UPS units. A puffed or distorted cell is a safety stop-work sign and goes to an authorised recycler. More in “Power supplies, UPS sizing and battery safety” that swells has been damaged, and Apple’s safety guide says to stop using a phone whose battery may be damaged, because it can overheat or cause injury. Read the signs in this table before you open Settings:

The indicator is normally white or silver and turns fully red after contact with water, but Apple still asks for an inspection before anyone blames a fault on liquid. The 80 percent row is the trap in the other direction: it looks like a failing battery, and it is Optimized Battery Charging or the charge limit of an iPhone 15 or later doing its job.

Practise: plan a clean-up that keeps the user’s data

Turn the storage piles into a plan. The function you write picks what to clear on the lesson’s tablet, largest safe item first, and gives up rather than touch data that is not backed up. The starter reaches every target by deleting whatever is biggest, which is exactly what the tests catch:

def plan_cleanup(items, available_mb, target_mb):
    """Return the names of the items to clear, largest safe item first.

    items are dicts with "name", "mb" (the space clearing it frees) and
    "keeps_data" (True when clearing it loses nothing). Stop once
    available_mb plus the space freed reaches target_mb. Return None when
    the safe items cannot reach the target.
    """
    # This version clears the biggest items whatever they hold: it reaches
    # the target, but it deletes videos that are not backed up anywhere.
    plan = []
    freed = 0
    for item in sorted(items, key=lambda i: i["mb"], reverse=True):
        if available_mb + freed >= target_mb:
            break
        plan.append(item["name"])
        freed += item["mb"]
    return plan

from cleanup import plan_cleanup


def tablet():
    """The lesson's tablet: what clearing each item frees, and whether it loses data."""
    return [
        {"name": "Videos backed up to Google Photos", "mb": 14_600, "keeps_data": True},
        {"name": "Videos that are not backed up", "mb": 6_300, "keeps_data": False},
        {"name": "Chat photos and voice notes", "mb": 5_200, "keeps_data": False},
        {"name": "Films downloaded for offline use", "mb": 4_100, "keeps_data": True},
        {"name": "Apps not opened in months", "mb": 3_800, "keeps_data": True},
        {"name": "Downloads folder", "mb": 2_400, "keeps_data": False},
        {"name": "App caches", "mb": 1_900, "keeps_data": True},
    ]


def test_one_item_is_enough():
    """clears only the backed-up videos to reach 8,000 MB from 700 MB"""
    assert plan_cleanup(tablet(), 700, 8_000) == ["Videos backed up to Google Photos"]


def test_largest_safe_items_first():
    """adds the offline films and the unused apps to reach 20,000 MB"""
    assert plan_cleanup(tablet(), 700, 20_000) == [
        "Videos backed up to Google Photos",
        "Films downloaded for offline use",
        "Apps not opened in months",
    ]


def test_never_loses_data():
    """returns None when only unsafe items could reach the target"""
    assert plan_cleanup(tablet(), 700, 30_000) is None
    assert plan_cleanup(tablet(), 700, 25_100) == [
        "Videos backed up to Google Photos",
        "Films downloaded for offline use",
        "Apps not opened in months",
        "App caches",
    ]


def test_already_enough_space():
    """clears nothing when the space is already there"""
    assert plan_cleanup(tablet(), 9_000, 8_000) == []
    assert plan_cleanup(tablet(), 8_000, 8_000) == []


def test_lands_exactly_on_the_target():
    """stops at an item that brings the space exactly to the target"""
    items = [
        {"name": "cache", "mb": 1_300, "keeps_data": True},
        {"name": "films", "mb": 900, "keeps_data": True},
    ]
    assert plan_cleanup(items, 700, 2_000) == ["cache"]
    assert plan_cleanup(items, 700, 2_001) == ["cache", "films"]


def test_same_size_keeps_the_given_order():
    """takes items of the same size in the order they were given"""
    items = [
        {"name": "music", "mb": 500, "keeps_data": True},
        {"name": "maps", "mb": 500, "keeps_data": True},
        {"name": "podcasts", "mb": 500, "keeps_data": True},
    ]
    assert plan_cleanup(items, 0, 1_000) == ["music", "maps"]


def test_keeps_the_list():
    """leaves the list of items it is given unchanged"""
    items = tablet()
    plan_cleanup(items, 700, 20_000)
    assert items == tablet()

The self-check below opens on whichever mobile-support topic your earlier answers show you need most, and widens from there as those answers improve:

Interview questions

Warm-up (fresher to 2–5 years): what do you check first when a user’s hotspot is not working?

Start on the phone that shares the connection, because a laptop that sees other networks has done its part. On an iPhone, open Settings > Personal Hotspot and check that Allow Others to Join is on; if the switch is missing or will not turn on, Apple’s advice is to check that the carrier has enabled hotspot on the plan, and Google warns that some carriers limit or charge extra for tethering. Then restart both devices. Only after those cheap checks would you reset network settings, and you would warn the user first, because the reset also erases saved Wi-Fi networks and VPN settings.

The next two questions take this lesson into situations a support interview likes to probe: mail that stops after a change the user made, and a full device the user cannot explain. Work out your first two moves for each one before you open it.

Key takeaways

• Exchange Online refuses Basic authentication in every tenant, so add work mail with Sign In or Outlook, and fix a manually configured account by removing it and adding it back.
• A hotspot nobody can see is usually switched off, missing from the carrier plan or in need of a restart; reset network settings last, because it erases saved networks and VPN settings.
• Fix apps from the cheapest rung up: close and reopen, check storage, update, clear the cache or offload, and only then delete and reinstall.
• Sort storage by what clearing it costs before you delete anything, and back up data that exists only on the device first.
• Swelling, red liquid indicators, liquid alerts and cracked glass are repair-shop faults; finish the backup and release Find My or confirm the Google Account before the phone leaves.