Read a sample: 1. Think Like an Application Troubleshooter
A production alert says an application cannot complete an order. The API returned an error, the function log contains a storage exception, and a recent deployment changed an environment variable. Each observation may matter, but none tells the whole story by itself.
The first response is not to grant broader permissions, redeploy the application, or increase a timeout. It is to determine what the application tried to do, where that attempt failed, and what evidence would distinguish the leading explanations.
That discipline is useful both in practice and on the AWS Certified Developer Associate exam. Troubleshooting questions often present several technically plausible actions. More than one may be capable of changing the outcome, but the strongest choice addresses the supported cause while respecting the requirements in the scenario. If the evidence is incomplete, the best choice may be a diagnostic step rather than a fix.
This chapter introduces a process you can carry into every scenario in this book. The services and error messages will change; the reasoning pattern will not.
A symptom is an observable result: an HTTP error, a failed function invocation, an item that was not written, or a message that remains unprocessed. A cause explains why that result occurred.
The distinction sounds simple, but troubleshooting questions often place the symptom and a tempting solution close together:
> A function receives an access-denied error when reading an object from Amazon S3. Should its execution role receive full access to S3?
The error supports an authorization-related investigation. It does not establish that the function needs full access, or even that the identity policy is the only relevant control. The function might be using an unexpected role, requesting the wrong bucket or object, or encountering an explicit deny. A broad permission change could be ineffective, excessive, or both.
Translate the report into a precise statement before evaluating remedies:
- Actor: Which component made the request?
- Operation: What did it attempt to do?
- Target: Which resource did it attempt to use?
- Result: What response or observable failure occurred?
- Context: When did it happen, and what had changed?
For example, “the order application is broken” becomes “the order-processing Lambda function receives an access-denied response while requesting an object from the configured S3 bucket after a deployment.” That statement still does not identify the cause, but it creates useful boundaries for the investigation.
Be careful with words such as after. A deployment preceding an error is a reason to inspect the deployment, not proof that the deployment caused it. The same discipline applies to an exam question: use the timeline as evidence, but do not let proximity substitute for a causal connection.
Applications are chains of operations. A client calls an API, the API invokes a function, and the function calls a database or another service. The component that reports an error may only be reporting what happened farther downstream.
Suppose an API client receives a server error. That response establishes that the client did not receive a successful result. It does not, by itself, establish whether:
- The API could not invoke the function.
- The function ran and returned an invalid integration response.
- The function encountered an application exception.
- A downstream service rejected or failed a request.
- A timeout occurred somewhere along the path.
The investigation should move from the visible symptom toward the earliest supported failure. An API response is useful evidence, but a function invocation record, application log, or trace may narrow the cause further.
This does not mean the deepest component is always responsible. A function may receive a database error because it supplied an incorrect table name. The database reports the failed request; the application configuration introduced the mistake. Similarly, an API may report an integration failure because its invocation permission is missing, in which case the function may never run.
Think in terms of a causal chain:
1. The client observed an unsuccessful response.
2. The API attempted an integration.
3. The function either did or did not run.
4. If it ran, the function attempted one or more operations.
5. A particular operation produced the first failure supported by the evidence.
The first observed failure is not automatically the root cause, but it is usually a better starting point than the final error shown to the user. Continue asking what condition made that operation fail.
A practical troubleshooting loop has five steps: define the symptom, map the request, form hypotheses, gather discriminating evidence, and choose a targeted action. After the action, verify the result and watch for unintended effects.
Record what failed and what still works. A single request failing is different from every request failing. A read failing while a write succeeds may point toward a different operation, resource, or permission. A function that never starts presents a different problem from one that starts and throws an exception.
Avoid silently filling gaps. If a question says “the deployment succeeded,” do not assume that the application is healthy. If it says “no application log appears,” do not assume the function was never invoked. The question may not have supplied enough evidence for either conclusion.
Identify the caller, the target, and the path between them. For a Lambda function calling DynamoDB, relevant details may include the function version receiving traffic, the execution role used by that version, the configured table name, and the operation attempted.
This map need…