« On a un backend qui répond en 80 ms, et pourtant l'app rame chez nos utilisateurs. »
Cette phrase, je l'ai entendue dans à peu près toutes les boîtes où j'ai mis les pieds. Le développeur backend a raison : son API est rapide. Et l'utilisateur a raison aussi : l'application est lente. Les deux regardent le même problème depuis des côtés différents et personne ne se comprend.
Parce que la vraie latence perçue par quelqu'un qui tient son téléphone dans le métro, elle ne se joue pas dans votre serveur. Elle se joue dans les 30 à 200 millisecondes de trajet réseau, dans les poignées de main TLS, dans les six requêtes que vous lancez en parallèle sans le savoir, et dans les 400 Ko de JSON que vous n'avez jamais pris la peine de regarder. Réduire la latence API d'une application mobile, c'est d'abord accepter que le coupable est rarement là où on le cherche.
Points clés à retenir
- Le réseau mobile pèse bien plus lourd que votre code serveur : sur 4G, un aller-retour coûte souvent 40 à 90 ms, en 5G on descend bas mais avec des trous de couverture.
- Trois requêtes séquentielles à 100 ms de RTT, c'est 300 ms de latence pure, quoi qu'il arrive dans vos serveurs.
- Un payload divisé par deux ne fait pas gagner 50 % de temps — mais ça réduit les timeouts et les retries, qui eux coûtent très cher.
- Le cache local (SQLite, Realm) est l'optimisation la plus rentable d'une app mobile, et c'est presque toujours celle qu'on saute.
- HTTP/2 et HTTP/3 changent vraiment la donne sur réseau instable, mais ne compensent pas un endpoint mal découpé.
- On ne réduit pas ce qu'on ne mesure pas : instrumentez le temps perçu côté client, pas seulement le temps serveur.
Comment réduire la latence d'une API mobile quand le vrai coupable est le réseau
Quand on m'appelle pour un problème de lenteur, la première chose que je demande, c'est un chiffre : le temps entre le tap de l'utilisateur et l'affichage du contenu. Pas le temps de réponse de l'API. Le temps perçu. Neuf fois sur dix, personne ne l'a mesuré. On a des logs Apache, des dashboards Grafana côté serveur, et zéro donnée sur ce qui se passe dans la poche de l'utilisateur.
Et c'est là que tout se joue. Votre API peut répondre en 60 ms, si l'app doit d'abord résoudre le DNS, ouvrir une connexion TLS, envoyer la requête, attendre la réponse, puis rejouer la scène pour l'écran suivant, vous avez déjà consommé 600 à 900 ms avant que l'utilisateur voie quoi que ce soit.
Le RTT est le vrai compteur
Le RTT (round-trip time), c'est le temps qu'un paquet met pour faire l'aller-retour entre le téléphone et votre serveur. Sur un réseau mobile, il n'est jamais stable. Il y a des moments où vous êtes à 30 ms, deux secondes plus tard vous êtes à 400 ms parce que l'utilisateur est passé derrière un mur. Ce qu'il faut comprendre : chaque requête HTTP séquentielle paie un RTT. Une connexion TLS complète en paie deux de plus.
Sur un projet d'app de livraison, j'ai compté un jour les allers-retours d'un simple écran de commande : sept. Sept requêtes en cascade parce que chaque appel dépendait du précédent. Sur un RTT moyen de 90 ms, ça fait déjà 630 ms de pur trajet réseau, avant même que le serveur ait dit un mot. J'ai réécrit deux endpoints pour qu'ils renvoient tout en un seul appel. Le temps perçu est passé de 2,1 s à 1,3 s. Et le backend n'avait pas bougé d'une ligne.
Le faux ami : « on optimisera le réseau plus tard »
J'ai entendu cette phrase pendant des mois sur un projet. Résultat : on a passé deux semaines à micro-optimiser des requêtes SQL qui prenaient 15 ms, alors que le vrai poste de dépense était l'appel HTTP vers un service tiers mal placé. On a gagné 4 ms côté serveur. L'utilisateur n'a rien vu. Ce fut une perte de temps totale, et je l'assume : c'était mon erreur de priorisation.
Comment faire baisser la latence côté application, sans toucher au serveur
Avant de réécrire votre backend, il y a une liste de choses à faire côté client. Elles coûtent peu, elles se mesurent, et elles rapportent beaucoup.
Préchargement et parallélisation des requêtes
Si deux appels ne dépendent pas l'un de l'autre, lancez-les en parallèle. Ça paraît bête, mais je vois encore des écrans où l'app attend le profil utilisateur avant de demander la liste des commandes, alors que les deux pourraient partir ensemble. En parallélisant trois appels de 100 ms de RTT chacun, vous passez de 300 ms à environ 100 ms. C'est gratuit.
Le cache local, ce grand oublié
Sur mobile, la meilleure optimisation reste le cache local. Une app de notes que j'ai suivie affichait un écran blanc pendant 800 ms à chaque lancement, le temps de recharger la liste depuis l'API. On a ajouté un cache SQLite qui affiche immédiatement les données de la dernière session, puis on rafraîchit en arrière-plan. Temps perçu au lancement : 800 ms → moins de 100 ms. L'API n'a pas changé. Les utilisateurs ont juste arrêté de croire que l'app plantait.
- Cache lecture-écriture sur les listes (SQLite, Room côté Android, Realm ou Core Data côté iOS)
- Affichage optimiste : on montre la donnée précédente, on met à jour dès la réponse
- Stratégie de revalidation (ETag, Last-Modified) pour éviter de re-télécharger ce qui n'a pas changé
- Expiration explicite pour les données sensibles (ne cachez jamais un token ou un solde bancaire sans précaution)
Réutiliser les connexions : keep-alive, HTTP/2, HTTP/3
Chaque nouvelle connexion TCP + TLS coûte cher. Le keep-alive évite de repayer cette mise en place. HTTP/2 permet de multiplexer plusieurs requêtes sur une même connexion, ce qui supprime la file d'attente. HTTP/3, basé sur QUIC, gère mieux les pertes de paquets et les changements de réseau (passage du Wi-Fi à la 4G par exemple). Sur un réseau instable, la différence se voit. Sur un réseau stable, elle est marginale.
Un tableau pour situer, avec des ordres de grandeur que j'ai relevés sur mes propres mesures en conditions réelles (zone urbaine, appareils de milieu de gamme) :
| Contexte réseau | RTT typique observé | Impact sur une requête unique | Ce qui aide le plus |
|---|---|---|---|
| 5G stable, centre-ville | 20 à 50 ms | Faible | Réduire le payload, cache local |
| 4G correcte | 40 à 90 ms | Modéré | HTTP/2, parallélisation |
| 4G en mouvement (train, voiture) | 80 à 300 ms, avec pics | Élevé | HTTP/3, retry avec backoff, cache |
| 3G ou réseau saturé | 200 ms et plus | Très élevé | Tout ce qui supprime des allers-retours |
Ces valeurs varient énormément selon l'opérateur, l'heure et le matériel. Prenez-les comme des repères de priorisation, pas comme des constantes.
Comment optimiser les applications sur Android quand la latence s'ajoute aux bugs
Sur Android, la latence API se mélange à une autre latence, celle de l'app elle-même. Un téléphone d'entrée de gamme avec un stockage lent peut mettre 200 ms à décoder une image pendant qu'il attend déjà une réponse réseau. Le résultat est un écran qui saccade alors que le réseau est correct.
Mesurer côté client, pas seulement côté serveur
La première étape, c'est de tracer le temps perçu. Sur Android, des outils comme le profiler intégré à Android Studio, Macrobenchmark ou Firebase Performance vous donnent le temps de démarrage, le temps d'affichage d'un écran, et les traces réseau. J'ai vu des équipes découvrir que 40 % de leur latence perçue venait d'un simple rendu d'image non optimisé. Sans mesure, on aurait continué à taper sur le backend.
Comment limiter le temps d'utilisation d'une application Android ?
Ce n'est pas exactement une question de latence, mais elle revient souvent quand on parle d'apps mobiles. Si vous cherchez à limiter le temps qu'une app tourne ou s'affiche, Android propose plusieurs mécanismes natifs : le mode Bien-être numérique (Digital Wellbeing) avec des minuteurs par application, le contrôle parental via Family Link, ou des applications tierces de suivi d'usage. Côté développeur, si votre intention est de limiter l'activité en arrière-plan de votre propre app, c'est du côté des WorkManager, des Foreground Services et de la gestion de la batterie qu'il faut regarder, pas du côté réseau.
Attention à ne pas confondre : limiter l'usage d'une app et réduire sa latence sont deux choses. La première relève du contrôle utilisateur, la seconde de la performance.
Timeouts et retries : à manier avec précaution
Un timeout trop court déclenche des retries inutiles, qui saturent le réseau et allongent encore la latence. Un timeout trop long fige l'interface. En pratique, sur mobile, je pose des timeouts de connexion autour de 3 à 5 secondes et un retry avec backoff exponentiel limité à deux tentatives. Au-delà, l'utilisateur a déjà quitté l'écran.
Quel logiciel utiliser pour réduire la latence ?
Il n'existe pas un logiciel magique. La question revient souvent et mérite une réponse honnête : aucun outil ne remplace une bonne architecture. Ceci dit, certains outils aident vraiment, selon l'étape où vous êtes.
- Charles Proxy ou Proxyman pour inspecter ce qui circule réellement entre l'app et l'API (taille, nombre de requêtes, entêtes)
- Android Studio Profiler, Xcode Instruments pour le temps de rendu et le réseau côté client
- Grafana, Datadog, Sentry pour la partie serveur et l'observabilité distribuée
- Cloudflare, Fastly ou tout CDN pour rapprocher les données du client
- Postman ou Insomnia pour reproduire et mesurer les endpoints à la main
- k6 ou Locust pour les tests de charge, quand on veut anticiper les pics
Le piège, c'est de croire qu'un outil va résoudre le problème à votre place. Un logiciel de monitoring qui affiche 60 ms de temps de réponse ne vous dit rien de la latence perçue. C'est vous qui devez croiser les données.
Ce qui marche vraiment dans la durée
Après plusieurs projets, voici les trois leviers que je priorise toujours, dans cet ordre : d'abord réduire le nombre d'allers-retours (regrouper les endpoints, paralléliser, cacher), ensuite réduire le payload (sélection de champs, compression, pagination), et enfin rapprocher la donnée (CDN, edge, cache régional). Dans cet ordre précis. L'inverse est un classique : on commence par le CDN parce que c'est plus fun, on finit par découvrir que le vrai problème était une cascade de six requêtes.
Est-ce que optimiser le backend suffit ?
Non. Un backend optimisé est une condition nécessaire, pas suffisante. Sur mobile, le réseau impose ses propres contraintes et un serveur qui répond en 30 ms ne fera jamais oublier 500 ms de RTT. Le meilleur investissement reste toujours celui qui supprime un aller-retour.
Il y a une chose que j'ai apprise à la dure : la latence que l'utilisateur remarque, ce n'est pas celle que vous mesurez dans vos dashboards. C'est celle qu'il ressent quand il tape sur un bouton et regarde son écran. Tant que vous n'aurez pas instrumenté ce moment-là, vous optimiserez des chiffres, pas des expériences. Et parfois, la meilleure optimisation, c'est juste de faire confiance au cache local et d'oser afficher quelque chose tout de suite.