Country or region and language

    Choose your country or region and your language.

    Suggested for you

      All countries and regions

        Choose your character

        It shows in the top bar and on your profile. Change it any time.

        AWS associate developer certification

        Prepare for the AWS associate developer certification with a four-week study plan, a working Python example, and checks for security, deployment, and debugging.

        A person practicing on a laptop in a quiet workspace

        Prepare for the AWS associate developer certification by practicing application development, security, deployment, and troubleshooting on AWS. The official credential is AWS Certified Developer - Associate; use the four-week sequence below to build a small billing function, diagnose deliberate faults, and check your understanding with practice questions.

        The certification and your study route

        Your study route should connect each exam skill area to an action you can perform and explain. The areas are Development with AWS Services, Security, Deployment, and Troubleshooting and Optimization. Preparation isn't about learning every cloud service, and passing an exam isn't the same as demonstrating production experience.

        Start with the official AWS Certified Developer - Associate page on aws.amazon.com. Use its current exam guide to check scope, and check the page for the exam version, fees, format, and registration details. Don't infer the current version from search suggestions.

        For each topic, follow the same loop: establish a correct result, introduce a fault, identify evidence of the cause, and retest after correcting it. Keep an error log with the symptom, cause, correction, and successful retest.

        Development through a billing function

        Development practice starts with a function you can test locally before adding cloud configuration. An event is the input passed to the function. Here, a fictional Cebu support ticket has three billable hours at PHP 350 per hour.

        Run the following standalone example in Python 3. The context argument represents runtime information supplied by AWS Lambda; the local test passes no runtime information because the function doesn't use it.

        def lambda_handler(event, context):
            hours = event["hours"]
            if type(hours) is not int or hours < 1:
                raise ValueError("hours must be a positive integer")
            return {"ticket_id": event["ticket_id"], "total_php": hours * 350}
        
        print(lambda_handler({"ticket_id": "CEB-104", "hours": 3}, None))
        try:
            lambda_handler({"ticket_id": "CEB-104", "hours": -1}, None)
        except ValueError as error:
            print(str(error))

        The first call returns PHP 1050. The second call deliberately raises a validation error, which the test catches and prints:

        {'ticket_id': 'CEB-104', 'total_php': 1050}
        hours must be a positive integer

        Next, study AWS SDK calls, data storage, and messaging. An SDK is a software development kit used to call service APIs from code. For each service interaction, identify the request, expected response, and possible error. Study idempotency too: repeated delivery of the same request shouldn't create repeated effects, such as billing the same ticket twice.

        For a function fault to diagnose on the site, try the Maple function timeout case. Keep the billing function as your own separate exercise.

        Practice what this post teaches

        Security through permission checks

        Security practice requires you to separate the identity calling a function from the identity the function uses while running. An execution role is the permissions identity assumed by the running function.

        Trace three separate permission checks:

        • Invocation: can the caller invoke the function?
        • Logging: can the execution role write diagnostic logs?
        • Storage: can the execution role perform the required action on the chosen storage resource?

        Permission to invoke a function doesn't grant its execution role database access. For a deliberate fault, add a storage operation without its required permission. Find the denied action and resource in the error evidence before proposing a narrowly scoped correction. Don't grant administrator access as a debugging shortcut.

        Practice least privilege, meaning only the permissions needed for a task. Treat temporary credentials, encryption, and secret storage as separate decisions: credentials establish identity, encryption protects data, and secret storage keeps sensitive values out of source code. Don't put access keys or customer information into events or diagnostic logs.

        To trace a denied request on the site, work through the Orchard denied read case.

        Deployment through a repeatable release

        Deployment practice turns tested code into a release you can reproduce rather than an unrecorded console edit. Deployment artifacts are the files and configuration used to release an application.

        For an optional AWS Lambda console exercise, select a currently supported Python runtime. Put only the function definition from the example into the source file, leaving out the local print statements and test calls. Use these file and handler settings:

        Source file: lambda_function.py
        Handler: lambda_function.lambda_handler

        Invoke the function with this test event:

        {"ticket_id": "CEB-104", "hours": 3}

        The returned object should contain the same ticket identifier and total:

        {"ticket_id": "CEB-104", "total_php": 1050}

        A published function version is an immutable snapshot; an alias is a named reference to a version. Practice releasing a rate change from PHP 350 to PHP 400: record the expected total of PHP 1200, publish the change, and verify the result. Repoint the alias to the previous version to rehearse rollback, then verify PHP 1050 again.

        Connect those steps to an automated workflow that builds, tests, and deploys the application. Review current pricing before creating cloud resources, because exercises can incur charges, and remove resources you no longer need. Local Python execution doesn't test cloud permissions, packaging, or deployment behavior.

        Troubleshooting through deliberate faults

        Troubleshooting starts by classifying the failure before changing code or permissions. Separate an incorrect result, invalid input, an invocation error, and an error from another service the function calls.

        Repeat the negative-hours test, then remove the hours field from the event. Negative hours produce the intended ValueError; the missing field produces KeyError because the example looks up the field before checking whether it exists. Add a required-field check before the lookup, then rerun valid, negative, and missing-input tests. Confirm that missing input now produces a deliberate validation error rather than an unhandled lookup error.

        Practice reading Amazon CloudWatch logs, which record events, and metrics, which summarize measurements such as errors and duration. Tracing helps follow a request across services. Use the fictional ticket identifier to connect related log entries rather than logging the complete event.

        Also distinguish timeouts, where work exceeds a configured duration, from throttling, where requests exceed an allowed rate or capacity. Retries can repeat processing, so connect retry behavior to idempotency. The billing function doesn't reproduce distributed application behavior or cover the full exam guide.

        A four-week plan and readiness checks

        Use four weeks as an adjustable sequence, not a promise that every beginner will be ready in a month. Give extra time to any task you can't yet perform without copying.

        Organize your study around evidence:

        • Week one: read the current exam guide, build the function, and test valid, negative, and missing input. Record each fault and successful retest.
        • Week two: practice security and service interactions. Identify the caller, execution role, requested action, resource, and expected behavior when permission is missing.
        • Week three: rehearse deployment, rollback, and troubleshooting. Save expected and actual outputs, and explain which evidence distinguishes a code defect from a configuration problem.
        • Week four: use fresh Developer-focused practice questions and timed mock exams. For every mistake, return to the underlying skill and reproduce a related fault.

        For supplementary architecture practice, try Solutions Architect Associate practice exam A. It targets a different certification, so don't use its result as a Developer exam readiness measure.

        You're better prepared when you can reproduce core tasks independently, explain why alternative answers don't fit a scenario, and diagnose an unfamiliar variation. Repeated-question scores alone don't establish readiness, and none of these checks guarantees an exam result.

        Common questions

        What does an AWS Certified Developer - Associate do? The credential concerns developing, securing, deploying, and troubleshooting applications on AWS. Related work can include writing service integrations, managing application permissions, releasing changes, and diagnosing errors; the credential itself isn't a job role.

        How difficult is the AWS associate developer certification for a beginner? A beginner may need extra preparation in programming, permissions, and service interactions before scenario questions become useful. Start with the local function, then add cloud configuration one decision at a time.

        Where can you check the current exam version and cost? Use the official AWS Certified Developer - Associate page on aws.amazon.com. Check its current exam guide and registration information rather than relying on an older article or search snippet.

        Can you start preparing with free resources? Yes. You can start with official documentation and the local Python exercise without creating cloud resources. The Work Gym also offers the first unit of every course free without an account; check pricing separately before running AWS resources.

        Is the certification useful without production AWS experience? Preparation can give you a structured way to develop and assess your knowledge, but it doesn't replace production experience. In a portfolio or interview, show your code, test evidence, permission reasoning, and rollback notes, and describe the exercise honestly as practice.

        Practice what this post teaches

        Your Work Gym account

        Save your progress and pick up on another device. Your browser's progress comes with you.

        or

        You can keep practicing without an account.

        Help and feedback

        Ask a question, tell us what is not working, or share an idea. We reply by email.

        What is it about?

        We use it only to reply to you.