Welcome back,
and in this second lesson of this miniseries,
we're going to step through a simulated exam question
similar to what you might experience on the real exam.
I want to get you comfortable with how I approach questions
and how I select answers
because one of the things
which most students do struggle with in the exam
is answering all of the questions in time,
so the quicker that we can get through a given question,
the more time that we have
for answering all of the questions in the exam,
and the more chance that you have
for obtaining a good solid exam mark,
so let's jump in and get started straightaway,
so this time we're going to take a look
at a different question.
This is a little bit more detailed than the previous one.
This question states:
A serverless application uses API Gateway
to perform searches.
API Gateway is configured with a non-proxy integration
to a backing lambda function, which queries DynamoDB.
You need to ensure that a search string parameter
is included in the request.
What should you confirm
to ensure that this parameter is required?
Now, when I see the word confirm,
you can approach this as meaning confirm or configure,
so if I read, "What should you confirm," within a question,
I also interpret this to potentially mean
what should you configure?
So these two can be used interchangeably.
Now, normally I always begin the process
of answering a question
by performing keyword identification.
This is just a quick scan of the question
to determine what we need to focus on,
so go ahead and pause the video,
spend a few seconds looking at this yourself,
and then, when you're finished,
you can unpause the video and we can compare.
Okay, so let's move on
and look at what I identified in this question,
so in my case,
I identified that this is a serverless application.
That's important because it's useful
to know the type of architecture that you're dealing with.
I also identified the term non-proxy integration,
and the fact that this uses a lambda function
as its backing,
and it uses DynamoDB.
Now, this is something which comes with experience
because it's possible that none of these terms matter
when selecting an answer,
but I find it interesting
that all of these have been included,
specifically, the non-proxy integration.
The fact that the person creating the question
has gone to the effort to tell us
that it's a non-proxy integration
should give us a clue about which answer to pick.
The next part which jumps out is that you need to ensure
that a search string parameter is included with the request,
so when a client is making a request to API Gateway,
we want to ensure that the search string parameter
has to be included with that request.
Now, let's have a look at the answers
that we have available for this question.
We have a total of five.
Initially, based on just the sentence structure
of these answers,
you should be able to identify that we have one odd answer,
one which doesn't look like the others.
Answers one, two, four, and five share the same structure,
but with slightly different words,
answer three is different,
and that's always a good sign
because it potentially means
that we can quickly identify if it's relevant,
and if not, we can eliminate it.
Now, I chose this question
specifically because it has this answer.
Answer three makes no sense. It's vague.
It's just configuring a stage,
and it doesn't really have the ability
to impact the question scenario,
so what I like to do here
is to tentatively mark it as wrong.
If it changes later on, then we can always reconsider it,
but the question requires that we only choose one answer,
and so it's likely
that if one of the answers initially doesn't make sense,
that we can eliminate it,
and then have one less answer that we need to consider,
so just by doing that,
we've reduced the number of answers
that we need to consider in detail by 20%.
Not bad for a few seconds work.
Now, let's analyze the remaining answers in detail.
Again, we need to look to remove word fluff,
so words which have no meaning,
things which are repeated in every answer
or groups of answers,
and let's also look for important keywords,
so at this point, go ahead and pause the video,
give this process a go yourself,
so attempt to identify any word fluff
or any important keywords,
and when you've finished, you can resume the video,
and you can compare what you found versus what I found.
Okay, so let's have a look at what I found
in this group of answers.
All four of these answers
shares the text "configure the,"
and this means
that when it comes to the differences between the answers,
so why we pick between them,
it has no meaning because we only have to choose one answer,
and because that set of words, so "configure the,"
is shared between all four of the answers,
it can't make the difference between the answers,
and so it has no effect,
and so we can ignore "configure the."
That's entirely irrelevant to picking the correct answer.
Next, the answers are essentially grouped
into two different blocks.
Those at the top have integration as the third word,
and those at the bottom have method as the third word.
API integrations, specifically non-proxy ones,
which is why I've highlighted that keyword in the question,
are split into four different parts:
integration request, integration response,
method request, and method response.
Now, method request and method response
are concerned with the interaction with the client.
Integration request and integration response
are concerned with the interaction with the integration,
in this case, the lambda function.
Since the question talks about
ensuring a parameter is included with the request,
we can eliminate both of the integration answers
because they don't impact
how the client communicates with the API Gateway.
That leaves us with two possible answers,
so we're down to a 50% chance,
much better than the 20% that we originally had.
Now, if you remember the API Gateway lessons,
the method response is part one of the interaction.
It controls what the client needs to provide to an API.
The method response
controls how the API responds back to the client.
Based on this, we can actually eliminate the bottom answer
because it's the initial communication
that we're interested in, not the final part.
We want to insist
on the inclusion of a parameter within the request,
and so the correct answer
is to configure the method request,
so this is the first part of the communication
between the client and the API Gateway.
It's here, in this component,
where we can configure what's required
within that initial communication,
and so this is the correct answer,
and that's it for this question.
It's a pretty simple process.
You'll notice that part of the technique
is knowing the AWS technologies,
but another part is having the ability
to break questions apart
and understand which keywords are important and which not,
and that's a skill all by itself.
Now, I've included a small subset
of these question technique videos in the course.
If you do want to practice with more questions,
then make sure that you join the tech study Slack community.
I've included the link for this attached to this lesson,
and in addition, make sure you also join the channel
which I've also attached to this lesson.
This is a channel focused on exam questions,
and this is where you can pose any exam questions
and discuss it with other students in the same situation,
so students who are attempting AWS exams.
Now, that's everything for this lesson.
Thanks for following along.
Go ahead and complete the video,
and when you're ready,
I look forward to you joining me in the next.