{"id":18775,"date":"2026-09-22T09:58:21","date_gmt":"2026-09-22T09:58:21","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=18775"},"modified":"2026-09-22T09:58:21","modified_gmt":"2026-09-22T09:58:21","slug":"amazon-aws-certified-developer-associate-dva-c02-practice-test-questions-and-exam-dumps-part2-q21-40","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/amazon-aws-certified-developer-associate-dva-c02-practice-test-questions-and-exam-dumps-part2-q21-40\/","title":{"rendered":"Amazon AWS Certified Developer – Associate DVA-C02 Practice Test Questions and Exam Dumps Part2 Q21-40"},"content":{"rendered":"

View Full <\/b>Amazon AWS Certified Developer – Associate DVA-C02 Exam Dumps<\/b><\/a> and Practice Test Dumps.<\/b><\/h2>\n

 <\/p>\n

Question 21<\/b><\/h3>\n

A developer needs to allow a mobile application to upload files directly to an Amazon S3 bucket without exposing AWS credentials. Which solution should the developer use?<\/b><\/p>\n

    \n
  1. Store AWS access keys in the mobile application.<\/span><\/li>\n
  2. Create an IAM user with full S3 permissions.<\/span><\/li>\n
  3. Use an S3 bucket policy that allows anonymous uploads.<\/span><\/li>\n
  4. Generate S3 presigned URLs for uploads.<\/span><\/li>\n<\/ol>\n

    Correct Answer: 4<\/b><\/p>\n

    Explanation<\/b><\/p>\n

    S3 presigned URLs allow an application to provide temporary, limited access to an S3 object operation without exposing AWS credentials to the client. The server-side application can generate a presigned URL using credentials that have appropriate permissions. The mobile application then uses that URL to upload the object directly to S3. The URL automatically expires after the configured period. This approach reduces the need to distribute long-term AWS credentials to client applications and follows a more secure access pattern. Anonymous bucket access and embedding access keys in an application can create significant security risks.<\/span><\/p>\n

    Question 22<\/b><\/h3>\n

    A Lambda function reads messages from an Amazon SQS queue. The function sometimes takes several minutes to process a message. Which SQS setting should be configured appropriately to prevent messages from becoming visible while they are still being processed?<\/b><\/p>\n

      \n
    1. Visibility timeout<\/span><\/li>\n
    2. Message retention period<\/span><\/li>\n
    3. Delivery delay<\/span><\/li>\n
    4. Maximum message size<\/span><\/li>\n<\/ol>\n

      Correct Answer: 1<\/b><\/p>\n

      Explanation<\/b><\/p>\n

      The SQS visibility timeout controls how long a message remains temporarily invisible after a consumer receives it. If a Lambda function needs several minutes to process a message, the visibility timeout should be long enough to allow processing to complete successfully. If the timeout expires before processing finishes, the message can become visible again and may be processed by another consumer. The visibility timeout should generally be configured based on the expected processing duration, with consideration for retries and variations in execution time. Message retention and delivery delay serve different purposes and do not prevent duplicate processing caused by an insufficient visibility timeout.<\/span><\/p>\n

      Question 23<\/b><\/h3>\n

      A developer wants a DynamoDB query to return items for a specific partition key and sort key range. Which operation should the developer use?<\/b><\/p>\n

        \n
      1. Scan<\/span><\/li>\n
      2. BatchWriteItem<\/span><\/li>\n
      3. Query<\/span><\/li>\n
      4. GetItem<\/span><\/li>\n<\/ol>\n

        Correct Answer: 3<\/b><\/p>\n

        Explanation<\/b><\/p>\n

        The DynamoDB Query operation is designed to retrieve items using a specific partition key and can optionally apply conditions to the sort key. For example, a query can retrieve records belonging to one customer where the sort key falls within a particular range. Query operations are generally more efficient than scans because DynamoDB can directly locate items associated with the specified partition key. Scan examines items across a table or index and is typically less efficient for targeted retrieval. GetItem retrieves a single item using its complete primary key, while BatchWriteItem is intended for batch write and delete operations rather than range-based reads.<\/span><\/p>\n

        Question 24<\/b><\/h3>\n

        A developer needs to store database credentials used by an application and automatically rotate them. Which AWS service is most appropriate?<\/b><\/p>\n

          \n
        1. Amazon S3<\/span><\/li>\n
        2. AWS Secrets Manager<\/span><\/li>\n
        3. Amazon CloudWatch<\/span><\/li>\n
        4. Amazon EventBridge<\/span><\/li>\n<\/ol>\n

          Correct Answer: 2<\/b><\/p>\n

          Explanation<\/b><\/p>\n

          AWS Secrets Manager is designed to securely store sensitive information such as database credentials, API keys, and passwords. It also supports automated secret rotation for supported services and custom rotation workflows. Applications can retrieve secrets at runtime instead of embedding credentials directly in source code or configuration files. This reduces the risk of exposing sensitive information through repositories or deployment artifacts. Amazon S3 provides object storage, CloudWatch provides monitoring capabilities, and EventBridge handles event-driven integrations. For applications that need securely managed credentials with rotation capabilities, Secrets Manager is an appropriate choice.<\/span><\/p>\n

          Question 25<\/b><\/h3>\n

          A Lambda function needs to access an Amazon DynamoDB table. Which approach follows AWS security best practices?<\/b><\/p>\n

            \n
          1. Store an IAM access key in Lambda environment variables.<\/span><\/li>\n
          2. Embed AWS credentials directly in the Lambda source code.<\/span><\/li>\n
          3. Attach an IAM role with the required DynamoDB permissions to the Lambda function.<\/span><\/li>\n
          4. Make the DynamoDB table publicly accessible.<\/span><\/li>\n<\/ol>\n

            Correct Answer: 4<\/b><\/p>\n

            Explanation<\/b><\/p>\n

            Lambda functions should use execution roles to obtain temporary AWS credentials. The IAM role attached to the Lambda function should contain only the permissions required by the application, following the principle of least privilege. This eliminates the need to store long-term access keys in source code or environment variables. Making a DynamoDB table publicly accessible is insecure and unnecessary. The Lambda execution environment automatically receives temporary credentials associated with its execution role. AWS SDKs can use these credentials without the developer manually managing access keys, providing a safer and more maintainable authentication mechanism.<\/span><\/p>\n

            Question 26<\/b><\/h3>\n

            A developer needs messages sent to an Amazon SNS topic to be delivered independently to multiple applications. Which architecture should be used?<\/b><\/p>\n

              \n
            1. SNS topic with multiple SQS subscriptions<\/span><\/li>\n
            2. One SQS queue shared by all applications<\/span><\/li>\n
            3. Multiple Lambda functions polling the same SQS queue<\/span><\/li>\n
            4. A DynamoDB table used as a message broker<\/span><\/li>\n<\/ol>\n

              Correct Answer: 2<\/b><\/p>\n

              Explanation<\/b><\/p>\n

              Amazon SNS supports a publish\/subscribe model in which a single message published to a topic can be delivered to multiple subscribers. Creating separate SQS queues and subscribing each queue to the SNS topic allows each application to receive its own copy of every relevant message. Each consumer can process messages independently and at its own rate. If multiple applications share one SQS queue, messages are distributed among consumers rather than independently delivered to every application. This SNS-to-multiple-SQS pattern is commonly used to implement reliable fanout architectures while allowing each downstream application to maintain separate processing and retry behavior.<\/span><\/p>\n

              Question 27<\/b><\/h3>\n

              A developer wants to prevent a DynamoDB item from being overwritten if another process has already created it. Which feature should be used?<\/b><\/p>\n

                \n
              1. Conditional write<\/span><\/li>\n
              2. DynamoDB Streams<\/span><\/li>\n
              3. Global secondary index<\/span><\/li>\n
              4. Time to Live<\/span><\/li>\n<\/ol>\n

                Correct Answer: 1<\/b><\/p>\n

                Explanation<\/b><\/p>\n

                DynamoDB conditional writes allow an operation to succeed only when a specified condition is true. For example, an application creating a new item can use a condition such as attribute_not_exists on the primary key. If another process has already created the item, the condition fails and DynamoDB rejects the write rather than overwriting the existing record. This technique is useful for preventing duplicate creation and implementing optimistic concurrency controls. DynamoDB Streams records item-level changes, indexes improve query access patterns, and Time to Live automatically removes expired items. None of those features directly prevents an unwanted overwrite during a write operation.<\/span><\/p>\n

                Question 28<\/b><\/h3>\n

                A developer is building a REST API with Amazon API Gateway and needs to restrict access based on a user’s identity token. Which feature can be used?<\/b><\/p>\n

                  \n
                1. API Gateway caching<\/span><\/li>\n
                2. API Gateway authorizer<\/span><\/li>\n
                3. API Gateway stage variables<\/span><\/li>\n
                4. API Gateway usage plan only<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 3<\/b><\/p>\n

                  Explanation<\/b><\/p>\n

                  API Gateway authorizers can validate client credentials or tokens before allowing access to protected API resources. Depending on the API configuration, an authorizer can use mechanisms such as Amazon Cognito user pools or a Lambda-based authorization function. The authorizer evaluates the incoming request and determines whether the caller should be allowed to invoke the API. Caching improves response performance, stage variables provide configuration values for API stages, and usage plans help manage API keys and throttling. When access must be controlled according to a user’s identity token, an appropriate API Gateway authorization mechanism should be configured.<\/span><\/p>\n

                  Question 29<\/b><\/h3>\n

                  A developer wants to automatically retry transient failures when an AWS SDK request receives throttling responses. Which approach is most appropriate?<\/b><\/p>\n

                    \n
                  1. Disable retries completely.<\/span><\/li>\n
                  2. Use exponential backoff with jitter.<\/span><\/li>\n
                  3. Immediately send hundreds of identical requests.<\/span><\/li>\n
                  4. Store failed requests permanently in S3.<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 2<\/b><\/p>\n

                    Explanation<\/b><\/p>\n

                    Exponential backoff with jitter is a common strategy for handling transient failures and throttling. Instead of retrying immediately at the same rate, the application waits for increasingly longer intervals between attempts. Jitter introduces randomness into the delay, helping prevent many clients from retrying simultaneously and creating another traffic spike. AWS SDKs commonly provide retry behavior automatically, but developers should understand how retries interact with application logic. Excessive immediate retries can worsen throttling conditions. Failed requests should also be handled according to the application’s reliability requirements rather than simply storing every failure in S3.<\/span><\/p>\n

                    Question 30<\/b><\/h3>\n

                    A developer wants to run a Lambda function whenever a new object is created in a specific Amazon S3 bucket. Which configuration should be used?<\/b><\/p>\n

                      \n
                    1. S3 event notification<\/span><\/li>\n
                    2. S3 lifecycle rule<\/span><\/li>\n
                    3. S3 inventory<\/span><\/li>\n
                    4. S3 Transfer Acceleration<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 4<\/b><\/p>\n

                      Explanation<\/b><\/p>\n

                      Amazon S3 event notifications can invoke supported destinations when specific events occur, such as object creation. A Lambda function can be configured as a destination for relevant S3 events. This enables event-driven processing such as image resizing, metadata extraction, validation, or file transformation immediately after an object is uploaded. S3 lifecycle rules are used to transition or expire objects according to configured policies. S3 Inventory provides scheduled reports about objects, while Transfer Acceleration improves transfer performance for supported upload and download scenarios. Therefore, an S3 event notification is the appropriate mechanism for triggering Lambda in response to object creation.<\/span><\/p>\n

                      Question 31<\/b><\/h3>\n

                      A developer needs to store configuration values that are not highly sensitive and retrieve them from an application without hardcoding them in source code. Which AWS service can provide this capability?<\/b><\/p>\n

                        \n
                      1. Amazon CloudFront<\/span><\/li>\n
                      2. Amazon Kinesis Data Streams<\/span><\/li>\n
                      3. AWS Systems Manager Parameter Store<\/span><\/li>\n
                      4. Amazon Route 53<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 3<\/b><\/p>\n

                        Explanation<\/b><\/p>\n

                        AWS Systems Manager Parameter Store provides centralized storage for configuration values and parameters. Applications can retrieve these values at runtime instead of embedding configuration directly in source code. Parameter Store supports strings, string lists, and secure string parameters that can be encrypted using AWS KMS. It is useful for values such as application settings, environment-specific configuration, and service endpoints. CloudFront is a content delivery service, Kinesis Data Streams handles streaming data, and Route 53 provides DNS services. Parameter Store therefore provides a convenient way to separate application configuration from application code and deployment artifacts.<\/span><\/p>\n

                        Question 32<\/b><\/h3>\n

                        A developer is designing an application that requires exactly-once processing semantics for messages where duplicate processing must be minimized. Which SQS queue type should be considered?<\/b><\/p>\n

                          \n
                        1. Standard queue<\/span><\/li>\n
                        2. FIFO queue<\/span><\/li>\n
                        3. Delay queue<\/span><\/li>\n
                        4. Dead-letter queue<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 1<\/b><\/p>\n

                          Explanation<\/b><\/p>\n

                          Amazon SQS FIFO queues are designed for applications that require ordered message processing and deduplication capabilities. FIFO queues support message deduplication and message groups, helping applications process related messages in order while reducing duplicate delivery. Standard SQS queues provide very high throughput but use at-least-once delivery, meaning duplicate messages can occur. A delay queue controls when messages become available, while a dead-letter queue stores messages that could not be successfully processed after configured attempts. Although FIFO queues provide deduplication features, applications should still be designed to handle retries safely and use idempotent processing where practical.<\/span><\/p>\n

                          Question 33<\/b><\/h3>\n

                          A developer needs to encrypt sensitive data stored in Amazon S3 using customer-controlled encryption keys. Which AWS service should be used to manage the keys?<\/b><\/p>\n

                            \n
                          1. Amazon Inspector<\/span><\/li>\n
                          2. AWS CloudTrail<\/span><\/li>\n
                          3. AWS KMS<\/span><\/li>\n
                          4. Amazon GuardDuty<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 4<\/b><\/p>\n

                            Explanation<\/b><\/p>\n

                            AWS Key Management Service provides centralized management of cryptographic keys that can be used to protect data across AWS services. Amazon S3 can use KMS keys for server-side encryption through SSE-KMS. KMS also provides control over key policies and permissions, allowing organizations to determine which principals can use specific keys. CloudTrail records API activity, Inspector performs vulnerability assessments, and GuardDuty provides threat detection. When an application requires customer-controlled encryption keys for sensitive S3 data, integrating S3 with AWS KMS provides a managed and auditable encryption solution.<\/span><\/p>\n

                            Question 34<\/b><\/h3>\n

                            A developer wants a workflow to coordinate multiple AWS services with conditional branching and retry behavior. Which AWS service is designed for this purpose?<\/b><\/p>\n

                              \n
                            1. Amazon EventBridge<\/span><\/li>\n
                            2. AWS Step Functions<\/span><\/li>\n
                            3. Amazon SNS<\/span><\/li>\n
                            4. Amazon CloudFront<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 2<\/b><\/p>\n

                              Explanation<\/b><\/p>\n

                              AWS Step Functions is a workflow orchestration service that allows developers to coordinate multiple application components and AWS services. State machines can contain sequential tasks, parallel branches, choices, waits, retries, and error handling. This makes Step Functions useful for business workflows and distributed application processes that require multiple steps. EventBridge is primarily an event bus and event-routing service, SNS provides publish\/subscribe messaging, and CloudFront is a content delivery network. Step Functions can also integrate with Lambda and many other AWS services, reducing the amount of custom orchestration code that developers need to maintain.<\/span><\/p>\n

                              Question 35<\/b><\/h3>\n

                              A developer wants to monitor application logs generated by an AWS Lambda function. Which service should the developer use?<\/b><\/p>\n

                                \n
                              1. Amazon CloudWatch Logs<\/span><\/li>\n
                              2. Amazon S3 Glacier<\/span><\/li>\n
                              3. Amazon DynamoDB<\/span><\/li>\n
                              4. Amazon Route 53<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 1<\/b><\/p>\n

                                Explanation<\/b><\/p>\n

                                AWS Lambda automatically integrates with Amazon CloudWatch Logs when the function has the appropriate execution role permissions. Applications can write log messages using the supported runtime logging mechanisms, and those messages are stored in CloudWatch log groups and streams. Developers can use CloudWatch Logs to inspect execution output, troubleshoot failures, and analyze application behavior. CloudWatch also integrates with metrics and alarms for broader monitoring. S3 Glacier is designed for archival storage, DynamoDB is a database service, and Route 53 provides DNS functionality. CloudWatch Logs is therefore the appropriate service for centralized Lambda execution logs.<\/span><\/p>\n

                                Question 36<\/b><\/h3>\n

                                A developer needs to make a temporary private S3 object accessible to a user for a limited amount of time. Which solution should be implemented?<\/b><\/p>\n

                                  \n
                                1. Change the object’s ACL to public-read.<\/span><\/li>\n
                                2. Make the entire bucket public.<\/span><\/li>\n
                                3. Create a presigned URL with an expiration time.<\/span><\/li>\n
                                4. Disable S3 Block Public Access.<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 3<\/b><\/p>\n

                                  Explanation<\/b><\/p>\n

                                  An S3 presigned URL provides temporary access to a specific S3 object without requiring the object or bucket to become publicly accessible. The URL is generated using AWS credentials with the required permissions and includes an expiration time. The recipient can use the URL until it expires. This approach is commonly used for temporary downloads or uploads. Making a bucket or object public exposes resources more broadly than necessary, while disabling Block Public Access can introduce unnecessary security risks. Presigned URLs therefore provide a controlled method for granting time-limited access while keeping the underlying S3 resources private.<\/span><\/p>\n

                                  Question 37<\/b><\/h3>\n

                                  A developer wants to trigger processing whenever a specific DynamoDB item changes. Which feature can provide a stream of item-level modifications?<\/b><\/p>\n

                                    \n
                                  1. DynamoDB Accelerator<\/span><\/li>\n
                                  2. DynamoDB Streams<\/span><\/li>\n
                                  3. DynamoDB global tables<\/span><\/li>\n
                                  4. DynamoDB TTL<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 2<\/b><\/p>\n

                                    Explanation<\/b><\/p>\n

                                    DynamoDB Streams captures information about item-level changes in a DynamoDB table. Depending on the configured stream view type, records can contain information about the item before and after a modification. Applications can consume these records to trigger downstream processing, maintain derived data, synchronize systems, or implement event-driven workflows. DynamoDB Accelerator is an in-memory caching service, global tables provide multi-Region replication, and TTL automatically expires items. DynamoDB Streams is particularly useful when an application needs to react to inserts, updates, or deletes without continuously scanning the table for changes.<\/span><\/p>\n

                                    Question 38<\/b><\/h3>\n

                                    A developer wants to reduce latency for frequently requested database results in an application. Which approach is most appropriate?<\/b><\/p>\n

                                      \n
                                    1. Disable database indexes.<\/span><\/li>\n
                                    2. Add unnecessary database writes.<\/span><\/li>\n
                                    3. Use a caching layer such as Amazon ElastiCache.<\/span><\/li>\n
                                    4. Increase log retention periods.<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 4<\/b><\/p>\n

                                      Explanation<\/b><\/p>\n

                                      A caching layer can reduce application latency by keeping frequently accessed data in memory instead of requiring every request to reach the underlying database. Amazon ElastiCache supports managed in-memory data stores such as Redis and Memcached. Applications can retrieve frequently requested values from the cache and update or invalidate entries when the underlying data changes. This can reduce database load and improve response times. Disabling indexes or adding unnecessary writes does not provide this benefit. Log retention settings are related to monitoring and storage rather than application data retrieval performance. Cache design should also account for expiration, invalidation, and consistency requirements.<\/span><\/p>\n

                                      Question 39<\/b><\/h3>\n

                                      A developer is deploying a Lambda function and wants to keep separate configurations for development, staging, and production versions. Which Lambda feature can help manage immutable function versions and aliases?<\/b><\/p>\n

                                        \n
                                      1. Lambda versions and aliases<\/span><\/li>\n
                                      2. S3 lifecycle policies<\/span><\/li>\n
                                      3. DynamoDB Streams<\/span><\/li>\n
                                      4. API Gateway usage plans<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 1<\/b><\/p>\n

                                        Explanation<\/b><\/p>\n

                                        AWS Lambda versions allow developers to publish immutable snapshots of function code and configuration. Lambda aliases provide stable names that can point to specific published versions. For example, aliases such as development, staging, and production can reference different Lambda versions. This helps deployment pipelines promote tested versions without changing the application’s integration endpoint. Aliases can also be used with traffic shifting and deployment strategies. S3 lifecycle policies manage object storage, DynamoDB Streams captures database changes, and API Gateway usage plans control API access and throttling. Lambda versions and aliases are therefore useful for managing controlled deployments across environments.<\/span><\/p>\n

                                        Question 40<\/b><\/h3>\n

                                        A developer needs an event-driven service that can route events from AWS services and applications to different targets based on event patterns. Which service should be used?<\/b><\/p>\n

                                          \n
                                        1. Amazon SQS<\/span><\/li>\n
                                        2. Amazon RDS<\/span><\/li>\n
                                        3. Amazon EventBridge<\/span><\/li>\n
                                        4. Amazon ECR<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 3<\/b><\/p>\n

                                          Explanation<\/b><\/p>\n

                                          Amazon EventBridge is an event bus service designed to receive and route events from AWS services, applications, and supported SaaS sources. Developers can create rules that match event patterns and send matching events to targets such as Lambda functions, Step Functions workflows, SQS queues, SNS topics, and other supported destinations. This enables loosely coupled event-driven architectures. SQS is primarily a message queuing service, RDS provides managed relational databases, and ECR stores container images. EventBridge is particularly useful when applications need centralized event routing based on event content rather than direct point-to-point integrations.<\/span><\/p>\n

                                           <\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full Amazon AWS Certified Developer – Associate DVA-C02 Exam Dumps and Practice Test Dumps.   Question 21 A developer needs to allow a mobile application to upload files directly to an Amazon S3 bucket without exposing AWS credentials. Which solution should the developer use? Store AWS access keys in the mobile application. Create an […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[1648,1647],"tags":[],"_links":{"self":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18775"}],"collection":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/comments?post=18775"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18775\/revisions"}],"predecessor-version":[{"id":18776,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18775\/revisions\/18776"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=18775"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=18775"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=18775"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}