What should you know to pass the Certified Developer exam from Amazon Web Services? Well, let’s take a look.
As the name implies, the exam focuses on concepts surrounding the use of AWS for development. So what does that really mean regarding studying for the exam? Let’s think about it from our perspective as developers.
APIs, SDKs, and Debugging
If we want to develop applications on AWS, we need to interact with the APIs directly, or, often, we can use SDKs for various languages. We might have scripts making API calls to store or retrieve information from a database like DynamoDB, or we might use S3 to store static documents that we can reference from our application. Whatever the call, and whatever the service, it’s crucial that we understand how the interaction between our applications and the AWS platform works.
That means understanding what calls are available to us, as well as what error codes or HTTP status codes we should expect. It also means learning the syntax of requests and responses, since often our code needs to send that information to the AWS service in a particular format, and it needs to be able to parse responses.
For example, let’s say that we have a message being pushed out using Amazon SNS (Simple Notification Service) to an HTTP or HTTPS endpoint. To process that message, your application needs to know which headers to expect, as well as which name/value pairs are available in the message body. Some of these are:
Knowing what these parameters are and which ones are sent is not only really important when building applications that use Amazon SNS, but also to pass the certification exam.
So does that mean I’m telling you to memorize all of these parameters and calls? Yes and no. It wouldn’t hurt to be able to memorize API calls and responses but, if you’re anything like me, that’s just not realistic. Instead, I highly recommend that you spend the time understanding why a certain call is there, or why a certain parameter is there. Going back to our SNS example, it makes sense that we receive a MessageId, because that’s what uniquely identifies each message that we receive.
Here’s another example: With SWF, Amazon’s Simple Workflow Service, you have what are called workers and deciders. Both of them have specific tasks, and if there are questions regarding SWF on the exam, they’re both likely to show up, so it wouldn’t be a bad idea to memorize those terms. Again, though, it’s not just about memorizing. Not only is that a bad strategy to pass the exam because questions/answers are not often that simple, but it also doesn’t set you up for success in the workforce. If you spend just a little bit more time understanding what a worker and what a decider does, not only is your brain more likely to remember the terms, but you’re also not scratching your head if you end up having to write a decider.
I also mentioned earlier that we should be familiar with HTTP code responses.
Let’s say that we’re using DynamoDB as our database. DynamoDB uses throughput capacity to read/write data. We’ve provisioned throughput requirements for our maximum peak load, except we didn’t correctly anticipate growth in the future. So one day, our Python application reads way more data than our Throughput capacity can handle, and it receives an HTTP 400 error with message ProvisionedThroughputExceededException. Knowing what this HTTP status error means, as well as what the message means is crucial. On top of that, though, we should be aware how to handle this error. Is it a request we can retry? Is it a request that requires a change before we retry? Also, in this specific example, what does the error mean if we check and realize that we have enough provisioned capacity throughput for our entire table? Hint: you need to understand DynamoDB performance, and we’ll talk about this a little bit more in just a moment.
To wrap up this section, when it comes to SDKs, it is important to know how they are configured (e.g. how to set the region, how to pass in access keys, that sort of thing), and also which languages and platforms are supported.
Design & Performance
We just mentioned DynamoDB performance and how it can affect our applications, but this service is not the only one that has performance configurations. Amazon S3 is “infinitely scalable,” but if we get a large number of requests per second, we do need to understand how S3 works behind the scenes if we want the best performance.
The main trick here is understanding that designing for performance and designing for cost does not always go hand-in-hand. Amazon Web Services wants to make sure that you understand this.
What I mean is that you shouldn’t be surprised to see questions where there are two correct answers, but one of them is more cost-effective while the other is more performance-oriented. Along the same lines, you could see answers that are more performance-oriented but may not be the most efficient from a programming point of view. As in, the programming would require more logic with that kind of database design, but since the question is asking for the most performance, you should choose the performance answer. The same goes for high availability versus cost and making choices based off of needs.
How can you prepare for these kinds of questions? By understanding design and performance inside and out, and by also paying very close attention to what the question is asking you. Do not rush through the question. There could be a single word stuck in there that changes the meaning of what is asked, and therefore changes the answer.
When it comes to security, again, we need to look at it from a developer perspective. What should we know about security as a developer and when building applications that interact with AWS services? There are a few different sections of this for the CDA exam:
- Understanding the shared responsibility model
- IAM roles, access keys, policies, etc…
- S3 encryption
- Using the Security Token Service
- Using Virtual Private Clouds (VPCs)
Expect to see scenarios here of how to implement something like the Security Token service. Or whether it makes more sense to use IAM roles versus access keys in certain scenarios.
As developers, we also need to know how to use CloudFormation, and how to handle things like sessions with the Elastic Load Balancer, or ELB. Beyond that, however, we also need to know what is supported by services like those. What can CloudFormation do, and what can’t it do? What kind of syntax does it use, and which sections are required versus which are optional? Also, CloudFormation has intrinsic functions that you should understand and know about. When does using one function over the other make sense? When it comes to the ELB and your application, how should you handle session storage? How can you use AMIs to distribute your application to different instances under that load balancer if they use Auto Scaling?
Of course, we also have access to Elastic Beanstalk. EB can be used by developers to deploy code on infrastructure without having to setup or manage that infrastructure. What is supported by this platform?
These are the kinds of concepts you should be familiar with when going in the exam.
How can I learn all of this without shooting in the dark?
After reading this, you may feel overwhelmed because it seems like there is so much you need to know. That’s why studying for an AWS exam on your own can be a daunting task. What should you focus on? What won’t be on the exam? There’s no way to know if all you have is the AWS documentation and access to the platform.
That’s why we have training for Amazon Web Services, including the AWS Certified Developer exam course. Instead of shooting in the dark, you can focus exactly on what will be on the exam, and what you need to know if you want to be more knowledgeable and efficient in the workforce. That’s also why we make engineers – we don’t have exam dumps, we have training for engineers.