Protocol Reference · Selection Guide

VPN Protocols and Network Routes: A Technical Reference

Protocols determine how the client transmits data; routes determine where it travels. VPNAim covers 110+ countries and 220+ routes. To compare options, keep your location and use case fixed, then test routes and protocols separately.

Haven't connected your client yet? Follow the setup guide to get started, import your configuration, and verify the connection. This article skips installation and focuses on troubleshooting once you're connected: where to look when the first connection is slow, calls drop out, or your battery drains while idle.

How to compare protocols and routes

Break “connected” into measurable stages

A connection icon in the client usually means local traffic forwarding is enabled; it doesn't mean the destination has received a request. When you open a page for the first time, the client may need to resolve the server address, establish the outer transport, complete authentication, and connect to the destination through the exit. The destination must also resolve its own domain, complete an encrypted handshake, and process the request. The exact order varies by client and routing mode. Treating all wait time as “route latency” can send you changing settings that have nothing to do with the problem. Record when the client becomes ready, then when the service returns its first useful response. If the first time stays consistent but the second varies widely, investigate the path from the exit to the destination and the destination's own processing time.

Track new and reused connections separately. When the client starts, resolving the server name, completing the transport handshake, and initializing the local virtual network interface can all add time. On repeated refreshes, a request may reuse an existing connection or hit the cache. A slow first request followed by faster ones doesn't necessarily mean the route improved. To compare first connections, reset session state the same way each time. To assess everyday use, keep connections open and use realistic cache conditions. If the client can't disable connection reuse explicitly, label results as “fresh start” or “continuous use” rather than presenting a guess about internal protocol state as a measurement.

Add real-world metrics to speed tests

Round-trip time measures how long data takes to go out and back; jitter measures how much that time varies. Voice calls need a steady stream of data on time, so an occasional very late packet can hurt call quality more than a consistently slower route. Sustained throughput determines whether file transfers or video buffering can keep up; it can't be inferred from round-trip time. Small requests are more susceptible to handshake delays and server-side queuing. Record whether pages load properly, calls have dropouts, or downloads pause noticeably. A single speed-test peak can miss the moments that actually determine whether a connection is usable.

Different websites take different paths beyond the exit. A speed-test server may be close to the exit, while a video platform may choose a different content delivery node based on DNS resolution and request origin. To check whether a route works for remote work, test the documents, meeting tools, or workspaces you actually use—not an unrelated speed-test page. For services involving accounts or paid requests, use low-risk checks, such as opening an existing document or viewing read-only data. Don't test stability by repeatedly submitting forms, creating records, or launching batches of tasks.

Make comparisons easy to reproduce

Keep the device, access network, destination, and task fixed, then switch routes. Change protocols separately only when both options genuinely use the same route. If a node with the same name actually uses a different entry point, exit, or transport after a protocol switch, record it as a “combined comparison.” Alternate between options during the same time period so changes in your local network or the service aren't mistaken for protocol differences. Note whether system updates, cloud sync, screen sharing, or other uploads were running. Background load may be worth testing separately, but it shouldn't be mixed into a baseline comparison.

Recording what happened is more useful than assigning a score to each node. Note whether the client was stuck resolving, couldn't connect, connected but loaded slowly, or disconnected during use. Keep the category of any page error, but don't save account credentials or subscription URLs. If client logs identify the point of failure, match it to the time of the issue; if the logs are unclear, say what you couldn't confirm. That way, even after changing devices or networks, the same notes can help establish whether the problem recurs. For ways to measure failures and reconnections, see How to test route stability.

Shadowsocks and Trojan

Shadowsocks: proxy encapsulation, not a single traffic-routing mode

A common Shadowsocks setup sends application traffic from the client to a remote proxy, which then connects to the destination. Modern implementations commonly use encryption with integrity checks, but both ends must support the same method and forwarding mode. Routing an app through a local proxy and routing traffic through a system-level virtual network interface are separate things. If browsing works but a meeting app doesn't, first check whether the app's traffic actually passes through the client and whether its required transport is being forwarded. A web page opening successfully doesn't prove that every app uses the same DNS resolution and data path.

With common TCP forwarding, for example, the client first establishes a transport connection to the entry point, then sends the destination details and application data in protocol format. This doesn't inherently require a separate outer TLS handshake, so under the same conditions it can avoid that extra wait. The result changes if a plugin or another transport is added on top. The entry point still has to connect to the destination, and the destination's own encrypted handshake remains. UDP forwarding requires support from both ends and the network; seeing “UDP supported” in the client doesn't mean the entire application path supports it.

Trojan: outer TLS and certificate verification

A typical Trojan deployment uses TLS over TCP. The client first establishes a TLS session with the entry point and verifies the server's identity according to its configuration, then sends the protocol request. Certificate trust and hostname checks serve different purposes: trust validates the certificate chain, while the hostname check confirms that the connection is to the configured service. If it fails, check the system time, the entry name shown in the client, and where the configuration came from. If the same configuration works elsewhere, also check whether the current network is waiting for a public access sign-in. Skipping certificate checks to connect faster removes a crucial identity check and isn't a suitable troubleshooting step.

Outer TLS and a destination website's HTTPS connection don't verify the same thing. Outer TLS protects traffic between your device and the proxy entry point; the website's own connection verifies the destination. Even with the proxy connected, your browser may report an invalid destination certificate. To identify which layer failed, check whether the error appears in the client or the website, then compare with a familiar destination. If only one website fails, don't assume the entire route is down. If multiple services fail and the logs show that the outer handshake didn't complete, check the entry point and configuration first.

Compare connection setup, sustained transfer, and resource use separately

Opening a new Trojan connection adds TLS verification work and handshake time, but session resumption, connection reuse, and when the client opens the outer connection all affect the delay users actually see. Conversely, less encapsulation doesn't guarantee higher throughput: encryption implementation, the system network stack, data copying, and device performance all affect the ceiling. To compare resource use, run the same task with both options. Check resource use while the task is running and whether the client returns to idle afterward. A single momentary reading may also include page rendering or background sync rather than protocol overhead.

Start with what your client explicitly supports. For browsing and documents, compare how easily connections are established and whether everyday small requests keep stalling. If calls are unreliable, check forwarding and packet loss before choosing based on handshake steps. Some implementations can carry UDP traffic inside an ordered outer stream. Data can get through, but retransmission on the outer stream may hold things up. If downloads work but calls often drop out, investigate the call's actual forwarding mode and queueing separately; don't use a web test as a substitute for testing calls.

Both options can work for everyday proxy use; their names alone don't determine speed. Keep a combination that works reliably, and when problems arise, try another route in the same region. Once route differences are accounted for, adjust the protocol if needed. If the problem occurs on only one device, check that the configuration was imported correctly, the system time is right, and the app isn't being routed differently before investigating implementation differences. Reinstalling or changing several settings at once makes it hard to identify what helped—and loses a working setup you could have used for comparison.

VMess and VLESS

Separate the proxy protocol from the outer transport

VMess and VLESS can both be used with clients that support multiple transport options. When checking a configuration, look separately at how the proxy layer identifies the user, how the outer transport connects, and whether that transport uses encryption and server identity verification. The same protocol name can involve different outer encapsulation, connection reuse, or separate entry layers. For example, one setup may carry multiple requests over a long-lived connection, while another frequently reconnects for individual requests. Even with the same protocol name, small-request delays and recovery after a disconnect can differ.

Modern VMess configurations commonly use an authenticated handshake. Whether the payload is also encrypted depends on the configuration supported by both ends. Don't treat older and newer implementations as the same test setup. If an import fails in only one client, first check whether it supports the transport and security options actually used by the subscription, then review the full log. Seeing VMess as an option in the app doesn't tell you whether every combination is supported. If the log indicates an authentication failure, check the system time and whether the subscription is up to date rather than blaming every failure on route congestion.

VLESS security depends on the full configuration

Common VLESS configurations use lighter encapsulation at the proxy layer. That doesn't mean VLESS provides protection equivalent to outer TLS by itself. Check which layer provides encryption and server identity verification in the actual deployment, and whether the client can interpret those settings correctly. Don't assume all implementations or combinations offer the same capabilities. Using the complete subscription provided by the service is more reliable than copying a few options manually from another route, especially when the name, transport, and security settings are linked. If you're unsure about an import, compare the same configuration in a known-compatible client first.

Connection setup time depends on the outer transport and whether connections are reused. When an outer connection is already open, handling the protocol header may be a small part of the total wait. For a new connection, DNS resolution, the outer handshake, and the exit's connection to the destination may take longer. Don't infer that a lighter proxy layer makes the entire setup faster. To compare encapsulation overhead, use the same device, workload, and similar route, then compare processing time and load. If the result appears only after the proxy route changes, note that the paths differ.

Connection reuse cuts handshakes but changes the scope of failures

Connection reuse sends multiple logical requests over one shared transport connection. It often avoids repeated handshakes and works well for workflows with many short requests. The trade-off is a shared queue and a common point of failure: if the outer transport is a single ordered TCP stream, later data may have to wait for lost data to be retransmitted before it can be delivered. If downloads and interactive requests share the connection, the whole app may appear to stall at once. Pause high-volume tasks and see whether the problem goes away; that's more informative about queueing than switching protocols right away.

If recovery is slow, check whether the client is waiting for an existing connection to time out or has already re-established the outer connection but not the application session. Both can look like “nothing happens,” but they need different fixes. In the first case, compare disconnect detection and reconnection behavior. In the second, try a query that can be safely repeated or check whether the app's login session is still active. Don't assume every request can be retried automatically, especially if it submits an order, saves changes, or creates a task.

Choose in this order: verify compatibility and authentication, then compare real-world benefits of connection reuse against its failure costs. If a problem occurs only on one system, review its imported settings. If it occurs only under mixed workloads, test downloads and interactive tasks separately. If it occurs only at peak times, compare routes. Phrase conclusions as “this setup works better for this task on this device,” rather than treating a protocol name as a permanent winner. Recheck after changing the client, network, or destination service.

Hysteria2 and TUIC

UDP-based doesn't mean unreliable

Hysteria2 and TUIC are both based on QUIC. QUIC carries data over UDP but still handles encrypted handshakes, stream delivery, packet-loss recovery, and congestion control. With reliable streams, missing data must still be recovered before it can be delivered in order. With a suitable app and implementation, datagrams don't need reliable retransmission after they're no longer timely. Unlike a shared, ordered TCP byte stream, multiple streams don't necessarily have to wait together when one stream is missing data. They still share connection capacity, network bandwidth, and server resources, so queueing and congestion can still occur.

One key consideration with Hysteria2 is whether its sending strategy matches the network. Some configurations let a bandwidth target influence congestion-control behavior. It's a sender-side setting for pacing traffic, not a measurement of the route's capacity. Setting it too high can cause queueing and retransmissions at bottlenecks, affecting other traffic on the same network. Setting it conservatively doesn't guarantee a better interactive experience, either. Without a reliable estimate of capacity, keep the service or client defaults and test both idle and mixed workloads. Don't use a brief peak reading as the sending target for peak hours.

TUIC streams and forwarding modes

TUIC can carry proxy connections over QUIC, and client implementations and configurations may offer different UDP forwarding modes. First establish whether the application actually needs datagrams and whether the entry point supports the relevant mode. For real-time apps, voice data that arrives too late is usually no longer useful; files and documents, by contrast, must arrive complete. Test throughput with downloads and jitter and continuity with calls. One test doesn't have to cover both. Before changing forwarding modes, check that both ends support the option, then repeat the call test under the same conditions.

QUIC combines transport and security handshakes, which can reduce some connection setup round trips on a working route. If the session can be resumed, data may be sent sooner. Actual time to first response still depends on how quickly the destination connects and responds. Resource use is another trade-off: packet-loss recovery, per-packet encryption, and frequent traffic all require processing. System and client support for features such as packet coalescing also affects performance. UDP underneath doesn't guarantee lower battery use, and fewer handshake round trips don't guarantee faster recovery after a network change.

For UDP compatibility issues, compare transports first

If it works on your home network but repeatedly times out during the handshake on another network, first confirm that you've completed network access authentication, then compare with a TCP option in the same region. If TCP works but QUIC repeatedly times out, that shows only that the two transports are experiencing different conditions—not which router or network segment is responsible. If it connects briefly after sign-in but stops responding after sitting idle, also consider session state in network devices and the client's recovery behavior. Track initial connection failures, interruptions while active, and failures after idle separately to narrow down the problem.

Another pattern is that small requests work but larger transfers stall. Along with insufficient capacity, check whether the path can handle the size of individual packets: tunnel headers add overhead, and some paths don't forward larger packets reliably. Don't copy settings from another network or reduce packet size globally based on a single failure. First compare other routes on the same network and other transports on the same route, then check whether the client provides path-size details or handshake logs. Make reversible adjustments only when the issue is repeatable and the client documentation supports them.

On mobile devices, QUIC connection IDs can help validate a new path after the address changes, but the proxy app, operating system, and server all need to support migration. If the client restarts local forwarding during a network switch, existing app connections may still drop. Keeping a tested fallback is more practical than assuming one protocol can handle every network switch. Test fallback behavior with the same task: a connection being available doesn't mean a call has recovered, and an existing long-lived connection may not move to the new route automatically.

Direct, relayed, and IEPL routes

Break the path down into entry, transport, and exit

A route label describes how traffic enters and is carried; it doesn't describe the complete path from your device to a destination website. In general, break the path into three parts: device to entry point, transport within the service, and exit to the destination. Home internet and wireless interference mainly affect the start; interconnection between networks and transport capacity affect the middle; the exit provider and the destination's choice of content delivery node affect the last part. Even if the middle is in good shape, the final segment can still be congested or take a detour. A fast response from the client to the entry point doesn't mean the exit can reach the service just as quickly.

A typical direct route has no additional service relay; the device connects to the proxy entry point over the public internet. This doesn't mean traffic passes through only one network device. Inter-provider links, autonomous-system routing, and the physical path are still involved. If routing is favorable, avoiding a service relay may reduce round-trip time. If public interconnection is repeatedly congested at a particular time, queueing can erase that advantage. A direct route is a useful baseline, not a guarantee of the most stable option in a region.

A relayed route first connects to an intermediate node, which forwards traffic to the exit. Adding a segment doesn't necessarily increase the total delay users see: a relay may provide a better-connected route and avoid congestion in the original path. It can also add its own forwarding queues and failure points. If a relay is faster than a direct route, don't attribute the improvement to protocol optimization. Compare the same destination at the same time, then check whether the difference remains on another access network to better understand which segment is responsible.

Compare routes by transport
TypeRoute characteristicsWhat to check first
DirectConnects to the proxy over the public internetCross-network queueing and detours at typical usage times
RelayConnects to an intermediate node, then to the exitWhether a better route offsets the added forwarding overhead
IEPLSome cross-border traffic uses a dedicated linkWhether the entry or exit still encounters a public-network bottleneck

IEPL describes managed transport, not an end-to-end guarantee

IEPL generally refers to international Ethernet private line transport. When choosing a route, identify which segment uses it and whether that segment is the bottleneck you're trying to avoid. A private line can provide a more controlled path for the relevant segment, but the connection from your device to the entry point and from the exit to the destination usually still depends on public networks. Your connection may also be limited by wireless conditions, your home gateway, or shared upload capacity. A route label doesn't reveal utilization, entry-point quality, or whether the destination will accept the current exit or keep assigning the same content delivery node.

Geographic distance mainly affects propagation time, while actual latency also includes forwarding, queueing, and retransmissions. An exit city close to the destination doesn't guarantee a nearby entry point or a direct route. Choose a region based on where the service is hosted, any regional requirements, and your own tests. Check the node and route list to narrow down options, then compare different route types in the same region. If you change region, protocol, and route all at once, record only whether the new combination works; don't credit any one change by itself.

Test against multiple destinations to avoid false conclusions

If only one site is unreliable, the cause may be the route from the exit to that destination or a problem with the service itself. If several unrelated sites slow down at once, check the shared entry and transport first. A route can also have issues in only one direction: downloads may be steady while upload queueing disrupts calls. Match route choices to real tasks: test downloads, calls, and remote access separately rather than ranking entire regions. For regular work, retest during typical working hours instead of choosing based only on a lightly loaded first connection. A useful backup route should avoid the primary route's shared bottleneck, not just have a different display name.

Troubleshooting packet loss and peak-hour congestion

First determine whether packets are being dropped or simply delayed

When data arrives at a network segment faster than it can be sent onward, packets wait in a queue. The queue may fill before packets are dropped, so during peak hours interaction often gets sluggish before retransmissions or interruptions appear. Apps tolerate this differently. Buffered video can keep playing for a while, while call audio can't wait for every old packet to be recovered. When you notice a stall, note whether it coincides with uploads, sync, or a large download. If pausing background tasks helps, investigate shared links and queueing instead of focusing only on the client's protocol label.

Wireless interference, devices busy processing packets, and congestion between providers can all produce similar symptoms. First check whether the issue is reproducible on your local network: move closer to the access point or, if possible, compare with a wired connection, then test the gateway and the actual destination. Local problems usually affect multiple routes. If changing the access method fixes it, address local interference or gateway load first. If only one service route slows down repeatedly at certain times, that narrows it to that combination but doesn't confirm which device or network interconnection is at fault.

Don't treat probe results as application traffic

Common connectivity probes may use different routing rules from application traffic. An intermediate router not responding to probes, or lowering their priority when busy, doesn't mean it's dropping forwarded data too. If the destination and app work despite an anomaly at an intermediate hop, don't blame that device. The client's built-in latency reading may also measure the entry point, exit, or a dedicated probe address; check how the client measures it. Use the same probe method for comparisons, and log the results alongside actual response times, playback buffering, or call dropouts.

Handle DNS errors, outer-handshake timeouts, and timeouts during data transfer separately. If name resolution fails, check whether the domain is failing only on the current network and whether the request reaches the expected resolver. For handshake failures, check the system time, access method, and transport compatibility. For transfer interruptions, focus on the sending direction, outer reconnections, and application errors. If the destination clearly reports an authentication, rate-limit, or service error, investigate the service rather than relying on route changes. Distinguishing these stages prevents different failures from being grouped together as “unstable nodes.”

Cross-check off-peak, peak-hour, and fallback routes

First save a working baseline during a relatively quiet period, then repeat the same task during your usual busy hours. Keep the region, device, and destination fixed. Alternate between the current and candidate routes, allowing enough time to observe each one. If the current route repeatedly stalls during busy hours while the candidate completes the task under the same conditions, you have a basis for keeping it as a fallback. If both slow down, check the shared entry, access network, background uploads, or destination load first. If possible, repeat the test on another local access network to see whether the issue follows the device.

If the main symptom occurs during uploads, reduce concurrency, pause sync, and stop unrelated sharing tasks when the application allows, then check whether call audio recovers. If it occurs after a long-lived connection has been idle, test network idle time, the client running in the background, and the application session timeout separately. For long-running tasks that need to recover, prefer the app's resume or session-reconnect features rather than relying entirely on transport-level retransmission. Long-term notes need only include the scenario, time, route type, and error category—not the contents of your work.

When reporting a problem, include when it happened, what you compared, and which stage failed. Instead of just saying “it's slow,” say whether the same destination recovered after switching routes at the same time. Before attaching logs, remove subscription URLs, authentication fields, and internal hostnames. If you can't identify the stage, say so; you can still switch to a more reliable setup without knowing the exact cause. Reproduce the issue after things recover so troubleshooting doesn't disrupt an active meeting or file transfer.

Mobile battery use and platform differences

Battery drain depends on how long the connection stays active, not just encryption

Encryption and encapsulation use processing resources, but mobile battery life also depends on how long the wireless radio stays active, how often apps wake the device, and whether failed connections keep retrying. A route with a lighter handshake can use more power than a stable connection if it repeatedly times out on your network. Intermittent background requests can also wake the device over and over. Continuous playback depends more on the screen, decoding, wireless quality, and actual throughput. Compare screen-off idle, interactive browsing, and video or calls separately; don't combine them into a single conclusion about protocol power use.

Keepalives help maintain a connection or detect failures sooner, but sending them too often can increase traffic and wake-ups. Sending them less often may let an access device close an idle session, forcing another handshake next time. If you have to wait whenever you pick up your device again, don't start by making keepalives more aggressive. First find out whether the operating system paused the client, the outer connection expired while idle, or the destination app signed out. Note the screen state, access type, and recovery action to distinguish this from problems during continuous use.

Platform differences: system behavior to check first
PlatformWhere to lookWhat to compare
WindowsSystem proxy, routing, and background syncCheck the browser and target app separately
macOSNetwork extensions, sleep, and wakeTest the connection before and after waking
iOSBackground activity and changes in wireless accessCompare the same request before and after the screen turns off
AndroidBackground battery settings and client statusDistinguish a paused process from a connection timeout
LinuxApp proxy, system routing, and name resolutionCheck how the application actually sends outbound traffic

After switching networks, recheck the route and app session

When a device switches wireless networks, its address, default route, and resolver may all change. An existing TCP connection usually can't continue just by switching addresses. QUIC can support path migration, but whether it works depends on the implementation, network, and whether the client restarts forwarding. Successful migration of the outer connection also doesn't mean every app recovers seamlessly. If no important changes are being submitted, try a read-only action, switch networks, and check whether it continues; then send a new request. If the first request fails but the new one works, the new path is available. Next, check whether the app can resume its own work.

A system proxy may not cover every app, and system-level routing can conflict with other active network extensions. If the browser works but an app doesn't, first check whether it uses the system proxy, its own proxy, or the system route directly. If it's using the wrong path, check the client and system documentation for routing mode. If you're unsure, restore a known-working setup before changing one option at a time. On managed work devices, keep the existing settings and check with your administrator; don't make global changes to fix one app.

Run a repeatable battery comparison

On the same device, keep screen brightness, network location, and foreground task consistent. First observe the idle period, then perform the same task and see whether the client keeps reconnecting afterward. System battery statistics can help, but some usage may be attributed to system networking or the foreground app. If the difference is small, don't change your usual commute or work setup based on one reading. Recheck connection recovery and interruptions on a representative network first.

A good default is a combination that stays connected on networks you use regularly, recovers easily after a switch, and doesn't repeatedly wake the device in the background. If you often move between different networks, keep a fallback that passes the same tests. Don't change background permissions, protocols, and routes at the same time, and don't disable built-in system protections for a short-term test. Otherwise, even if battery use appears to improve, you won't know which change made the difference. If the problem occurs only after the screen has been off for a long time, focus on sleep and recovery instead of adding foreground download load.

Choose a protocol and route by use case

Work and calls: prioritize recovery

Web work relies on interactive requests, so start with a transport that connects reliably, verifies certificates correctly, and is fully supported by your client. For collaborative documents, check that opening, editing, and syncing all work smoothly; reaching the sign-in page alone doesn't verify saving or live collaboration. Calls depend more on consistent latency and continuity, so also test upload during screen sharing. If calls sound clear without sharing but break up when you share, reduce concurrent uploads or check the local queue before comparing another route. Test a fallback before a customer meeting so you don't have to switch regions and transports mid-call.

Remote access depends on timely feedback between an input and the resulting screen update; high throughput can't make up for irregular stalls. If you need to switch between mobile and fixed networks, test how quickly the app recovers after a new request, whether you need to sign in again, and how to check the status of an unfinished action. Don't resend a write request if you don't know whether it succeeded. In business environments, first confirm which routes and exits are allowed, then compare options within those requirements.

Streaming and downloads: test sustained delivery

Streaming availability depends on the platform's regional rules, account requirements, and the route from the exit to its content delivery node. Start by checking whether playback begins normally on the platform you use, then observe picture quality over time, recovery after seeking, and buffering during your usual viewing hours. A fast start doesn't guarantee consistent delivery. If only one platform has problems, check its error message and the route to that destination first. If several sustained transfers are unstable, investigate the transport and local access network.

For large file transfers, check whether the data arrives intact and whether the transfer can resume after a failure. If it stops, note whether it's still progressing slowly, the app exited with an error, or the outer connection reconnected. Resume support can reduce the cost of starting over, but it doesn't eliminate the impact of background downloads on calls. Test under your actual concurrent workload and reduce the app's own concurrency if needed. Plans cover data usage, not protocol performance. For budgeting based on your usage, see plan pricing and billing details; assess network quality with the tests above.

AI websites and APIs: check first response, errors, and streaming separately

With AI websites, sign-in, sending a prompt, and receiving a continuous response are separate stages. A slow first response may be caused by server processing or queueing; an interrupted response needs a check of transport stability and application timeouts. Loading the page doesn't prove the API works. For development, use a small number of safely repeatable requests to check name resolution, connection setup, and the response, and distinguish network timeouts from authentication, quota, or service errors returned by the destination. Changing exits won't fix application-level configuration. For more API-specific guidance, see Choosing a route for AI API requests.

For tasks that require a consistent exit, first check whether the route meets the relevant service requirements; don't assume a region name guarantees a fixed exit. For long-running tasks, plan how to recover from failures: read-only queries can be retried according to the app's policy, but before repeating a request that creates resources or incurs charges, confirm whether it was already processed and use the app's idempotency support where available. Record the error category and stage, but don't save access credentials. This helps distinguish a real improvement after switching routes from a request that happened to reach the service during a quieter period.

Keep a primary and a fallback, not a permanent ranking

Keep only conclusions that help with everyday decisions: which networks and tasks the primary works for, which failures the fallback addresses, and what symptoms should trigger a retest. Fix the destination region first to compare topology, then compare transports, and finally retest the setup on your actual devices and at typical times. If the client changes, your network environment shifts, or the service moves, repeat the same tests. The goal is a setup that handles the task at hand and recovers easily—not a permanent ranking that supposedly works for every device and service.

Try it free