{"id":20712,"date":"2026-09-24T06:57:12","date_gmt":"2026-09-24T06:57:12","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=20712"},"modified":"2026-09-24T06:57:12","modified_gmt":"2026-09-24T06:57:12","slug":"appian-acd201-practice-test-questions-and-exam-dumps-part10-q181-200","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/appian-acd201-practice-test-questions-and-exam-dumps-part10-q181-200\/","title":{"rendered":"Appian ACD201 Practice Test Questions and Exam Dumps Part10 Q181-200"},"content":{"rendered":"

View Full <\/b>Appian ACD201 Exam Dumps<\/b><\/a> and Practice Test Dumps.<\/b><\/p>\n


\n<\/b>Question 181. What is a Custom Data Type (CDT) primarily used for in Appian?<\/b><\/p>\n

    \n
  1. <\/b> To define site navigation and branding<\/span><\/li>\n
  2. <\/b> To control user authentication settings<\/span><\/li>\n
  3. <\/b> To schedule process-model execution<\/span><\/li>\n
  4. <\/b> To represent a structured logical grouping of related data<\/span><\/li>\n<\/ol>\n

    Correct Answer: 4. To represent a structured logical grouping of related data<\/b><\/p>\n

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

    A Custom Data Type, or CDT, defines a structured collection of related fields that represent a logical business entity such as an Employee, Contract, or Invoice. CDTs can be used for database persistence through data stores, process variables, plug-in inputs and outputs, and certain web service operations. Each field has an appropriate data type, allowing Appian to work with complex information as one structured value instead of many unrelated variables. Although modern Appian development commonly uses record types for business data access, CDTs remain important for data-store mappings, plug-ins, web services, and existing applications.<\/span><\/p>\n

    Question 182. Which two properties together uniquely identify an Appian Custom Data Type across environments?<\/b><\/p>\n

      \n
    1. <\/b> Description and folder<\/span><\/li>\n
    2. <\/b> Name and namespace<\/span><\/li>\n
    3. <\/b> Database table and primary key<\/span><\/li>\n
    4. <\/b> Application name and security role<\/span><\/li>\n<\/ol>\n

      Correct Answer: 2. Name and namespace<\/b><\/p>\n

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

      A CDT is uniquely identified by the combination of its name and namespace. These values form the identity used by Appian to recognize and reference the data type across environments and application objects. Because of this, Appian does not allow developers to change the CDT’s name or namespace after creation. A developer planning a new CDT should therefore choose both values carefully before completing the creation process. Other properties, including the description and visibility in data-type pickers, can be modified later. Maintaining consistent data-type identity is particularly important when CDTs are exported, imported, or updated between Appian environments.<\/span><\/p>\n

      Question 183. Before modifying a CDT that is already used throughout a production application, what should a senior developer do FIRST?<\/b><\/p>\n

        \n
      1. <\/b> Review the CDT’s dependents and assess the impact of the proposed change<\/span><\/li>\n
      2. <\/b> Delete the current CDT before creating the replacement<\/span><\/li>\n
      3. <\/b> Remove every field and rebuild the structure<\/span><\/li>\n
      4. <\/b> Disable all dependent interfaces<\/span><\/li>\n<\/ol>\n

        Correct Answer: 1. Review the CDT’s dependents and assess the impact of the proposed change<\/b><\/p>\n

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

        Changes to an established CDT can affect interfaces, process models, expressions, data stores, and other dependent objects. Appian therefore recommends using the Dependents view before updating the data type so developers can identify where it is used and evaluate the effect of the proposed modification. Production changes should also consider backward compatibility. Adding fields is generally less disruptive than renaming or removing existing fields because dependent objects may expect the original structure. If the CDT is mapped through a data store, developers must also ensure that the corresponding relational database schema remains compatible with the updated data-type definition.<\/span><\/p>\n

        Question 184. Which approach generally provides the safest backward compatibility when extending a production CDT?<\/b><\/p>\n

          \n
        1. <\/b> Rename all existing fields<\/span><\/li>\n
        2. <\/b> Change existing field data types<\/span><\/li>\n
        3. <\/b> Add new fields without removing or changing existing ones where possible<\/span><\/li>\n
        4. <\/b> Delete the CDT and recreate it with a different namespace<\/span><\/li>\n<\/ol>\n

          Correct Answer: 3. Add new fields without removing or changing existing ones where possible<\/b><\/p>\n

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

          When a CDT is already used by production objects, Appian recommends considering backward compatibility carefully. Adding fields is typically less disruptive than deleting existing fields, renaming them, or changing their types. Existing interfaces, rules, process variables, and data-store mappings may depend on the original structure. Removing or changing fields can therefore break references or make database mappings invalid. Adding fields still requires impact analysis, particularly when a data store is involved, but it usually preserves existing consumers more effectively. Senior developers should always evaluate dependents and database-schema implications before creating and deploying a new version of a CDT.<\/span><\/p>\n

          Question 185. What is a Data Store object used for in Appian?<\/b><\/p>\n

            \n
          1. <\/b> To configure application navigation<\/span><\/li>\n
          2. <\/b> To connect Appian data structures to an external relational database for persistence<\/span><\/li>\n
          3. <\/b> To control site page visibility<\/span><\/li>\n
          4. <\/b> To manage user passwords<\/span><\/li>\n<\/ol>\n

            Correct Answer: 2. To connect Appian data structures to an external relational database for persistence<\/b><\/p>\n

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

            A Data Store provides the connection between Appian data structures and relational database tables. It is used together with CDTs and data store entities to read and write application data in supported databases. Historically, data stores have also supported database-backed legacy record configurations and smart services that perform database operations. Modern Appian applications often use record types and data fabric capabilities for application data, but understanding data stores remains important for existing solutions, CDT persistence, and certain database operations. A data store is not an authentication object or presentation-layer feature; its primary responsibility is relational data persistence and access.<\/span><\/p>\n

            Question 186. A CDT mapped through a data store is changed by adding a database-backed field. What additional concern should the developer evaluate?<\/b><\/p>\n

              \n
            1. <\/b> Whether the application site has enough pages<\/span><\/li>\n
            2. <\/b> Whether all users have Administrator permission<\/span><\/li>\n
            3. <\/b> Whether the process model contains an AND gateway<\/span><\/li>\n
            4. <\/b> Whether the database schema and data-store mapping remain compatible with the updated CDT<\/span><\/li>\n<\/ol>\n

              Correct Answer: 4. Whether the database schema and data-store mapping remain compatible with the updated CDT<\/b><\/p>\n

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

              Updating a CDT that participates in a data-store mapping can immediately affect the associated data store. Even adding a field may invalidate the mapping if the underlying database table does not contain a compatible column or if other schema details differ from the CDT definition. Appian therefore warns developers about dependent data stores when certain CDT updates are performed. Teams should update the relational database structure accordingly or use supported automatic schema-update capabilities where appropriate. CDT changes should never be treated purely as application-layer modifications when the data type also represents persistent relational data.<\/span><\/p>\n

              Question 187. Which statement about security on Appian CDTs is correct?<\/b><\/p>\n

                \n
              1. <\/b> CDTs do not have their own object-security role maps; security is applied through the objects that reference them<\/span><\/li>\n
              2. <\/b> Every CDT automatically grants Viewer access to all users<\/span><\/li>\n
              3. <\/b> CDT security is inherited only from record types<\/span><\/li>\n
              4. <\/b> Each CDT must have a dedicated security group<\/span><\/li>\n<\/ol>\n

                Correct Answer: 1. CDTs do not have their own object-security role maps; security is applied through the objects that reference them<\/b><\/p>\n

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

                Unlike many Appian design objects, CDTs do not have independent security role maps. Instead, access is effectively governed through the objects that use the CDT. For example, if an interface references a CDT, the interface’s security determines whether a user can access that interface and its functionality. Only authorized designers and system administrators can perform supported design actions on data types themselves. This means developers should not expect to secure a CDT as though it were a record type, expression rule, or interface. Security needs to be designed around the application objects and data-access layers that actually expose or manipulate the information.<\/span><\/p>\n

                Question 188. When a new version of a CDT is created, what normally happens to dependent design objects?<\/b><\/p>\n

                  \n
                1. <\/b> They continue using the oldest CDT version indefinitely<\/span><\/li>\n
                2. <\/b> They are automatically deleted<\/span><\/li>\n
                3. <\/b> They begin using the new CDT version, except already running processes retain their existing process data behavior<\/span><\/li>\n
                4. <\/b> They must all be manually reopened and saved<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 3. They begin using the new CDT version, except already running processes retain their existing process data behavior<\/b><\/p>\n

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

                  When an Appian CDT is updated and a new version is created, dependent design objects generally begin using the new version immediately. This makes CDT changes potentially far-reaching, especially when the type is used by numerous interfaces, rules, process models, and data stores. Running processes are an important exception because changing the definition underneath active process data could otherwise create unpredictable behavior. This is another reason senior developers should perform dependency analysis and consider backward compatibility before modifying production data types. Changes to shared data structures should be treated as architectural changes rather than isolated edits.<\/span><\/p>\n

                  Question 189. Why are maps generally preferred over dictionaries for new Appian expression designs?<\/b><\/p>\n

                    \n
                  1. <\/b> Maps can only contain Text values<\/span><\/li>\n
                  2. <\/b> Dictionaries cannot contain multiple fields<\/span><\/li>\n
                  3. <\/b> Maps automatically persist values to a database<\/span><\/li>\n
                  4. <\/b> Values retrieved from dictionaries often require additional casting, while maps provide stronger type handling<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 4. Values retrieved from dictionaries often require additional casting, while maps provide stronger type handling<\/b><\/p>\n

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

                    Maps and dictionaries both allow developers to create ad hoc structures containing named fields and corresponding values. However, Appian recommends maps for most new development because values retrieved from dictionaries frequently need to be cast to the expected type before they can be used safely. Maps provide more convenient type handling and work naturally with modern Appian expression patterns. Dictionaries may still appear in older application code, so senior developers should understand both structures. When designing new reusable rules or interface logic, <\/span>a!map()<\/span> typically provides clearer and more predictable behavior than legacy dictionary syntax.<\/span><\/p>\n

                    Question 190. A user input task allows a user to edit a value that the process needs later. How should the data flow be configured?<\/b><\/p>\n

                      \n
                    1. <\/b> Map the process data through a node input to the interface rule input and save the submitted value back to a process variable<\/span><\/li>\n
                    2. <\/b> Save the interface value directly into a process variable without task mapping<\/span><\/li>\n
                    3. <\/b> Store the edited value in the process model description<\/span><\/li>\n
                    4. <\/b> Use a site URL parameter instead of process data<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 1. Map the process data through a node input to the interface rule input and save the submitted value back to a process variable<\/b><\/p>\n

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

                      When users edit information on a User Input Task form, the form rule input must participate in the task’s data mapping so the submitted value can be returned to the process. Process variables provide the data to the task through node inputs, and those node inputs are mapped to the interface rule inputs. When the task completes, the edited values are saved back into process variables for downstream activities. Appian does not allow interface form data to bypass this mechanism and write directly into process variables. Correct mapping ensures that user changes survive after the task completes and remain available later in the workflow.<\/span><\/p>\n

                      Question 191. A User Input Task displays a record value only for reference, and the user cannot edit it. Must the value always be mapped through a node input?<\/b><\/p>\n

                        \n
                      1. <\/b> Yes, every displayed value requires an activity-class parameter<\/span><\/li>\n
                      2. <\/b> Yes, otherwise the interface will not render<\/span><\/li>\n
                      3. <\/b> No. Read-only process data can be passed directly to the interface rule input when it does not need to be saved back<\/span><\/li>\n
                      4. <\/b> No, because process variables can never be used on task forms<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 3. No. Read-only process data can be passed directly to the interface rule input when it does not need to be saved back<\/b><\/p>\n

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

                        A node input mapping is necessary when a task form edits information that must be written back to the process. If process data is displayed only as read-only context, Appian allows the process value to be passed directly to the interface rule input without creating an unnecessary node input. This simplifies task configuration and keeps the data flow focused on information that actually changes. Senior developers should distinguish between values displayed for context and values being collected or modified. Creating redundant mappings can make complex process models harder to understand without providing any functional benefit.<\/span><\/p>\n

                        Question 192. Appian process variables, node inputs, node outputs, and rule inputs are strongly typed. What is a risk when incompatible data is saved between them?<\/b><\/p>\n

                          \n
                        1. <\/b> Appian permanently deletes the process instance<\/span><\/li>\n
                        2. <\/b> Appian may cast the value to the destination type, potentially changing it unexpectedly<\/span><\/li>\n
                        3. <\/b> Every value is automatically converted to a document<\/span><\/li>\n
                        4. <\/b> The application security role map is reset<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 2. Appian may cast the value to the destination type, potentially changing it unexpectedly<\/b><\/p>\n

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

                          Process data elements in Appian have defined data types. When values move between rule inputs, node inputs, node outputs, and process variables, developers should use compatible types. If a supplied value does not match the destination data type, Appian may attempt to cast it. That conversion can alter the value or produce unexpected behavior depending on the source and target types. Senior developers should therefore design data contracts deliberately rather than relying on implicit casting. Explicit type consistency makes process behavior easier to test, troubleshoot, and maintain, particularly when complex record or CDT structures move through several workflow activities.<\/span><\/p>\n

                          Question 193. A developer maps an entire CDT node input back into a process variable, but some CDT fields contain no new values. What can happen to those fields?<\/b><\/p>\n

                            \n
                          1. <\/b> Fields without new values can be set to null when the whole CDT is saved at the parent level<\/span><\/li>\n
                          2. <\/b> Appian automatically retrieves their previous values from the database<\/span><\/li>\n
                          3. <\/b> Appian removes the fields from the CDT definition<\/span><\/li>\n
                          4. <\/b> The task automatically remains active<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 1. Fields without new values can be set to null when the whole CDT is saved at the parent level<\/b><\/p>\n

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

                            When working with a CDT node input, developers can save either the entire CDT at its parent level or selected individual fields. If the entire CDT is saved back at the parent level, all fields are updated. Fields that do not contain new data can therefore be written as null, potentially overwriting values that the developer intended to preserve. This behavior makes field-level mapping important in update scenarios where only part of the CDT should change. Senior developers should understand the difference between replacing an entire structured value and updating selected fields to avoid accidental data loss in downstream processing.<\/span><\/p>\n

                            Question 194. What is a custom node output useful for in an Appian process model?<\/b><\/p>\n

                              \n
                            1. <\/b> It can only display a message to the user<\/span><\/li>\n
                            2. <\/b> It replaces the process-model security role map<\/span><\/li>\n
                            3. <\/b> It creates a new Appian site automatically<\/span><\/li>\n
                            4. <\/b> It allows developers to calculate or transform node results before saving them into process variables<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 4. It allows developers to calculate or transform node results before saving them into process variables<\/b><\/p>\n

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

                              Custom outputs provide additional flexibility when data produced by an activity should not simply be copied directly into a process variable. The developer can use an expression that references process variables, activity-class parameters, process properties, task properties, and other available context. Depending on the destination type, custom outputs can store, append, or mathematically modify values. For example, a numeric result could be added to an existing process total or a returned item could be appended to a list. Custom outputs allow process models to keep transformation logic close to the relevant activity while explicitly controlling how results update process state.<\/span><\/p>\n

                              Question 195. If one node output encounters an error that prevents it from writing to its target process variable, what happens to the other outputs from that same node?<\/b><\/p>\n

                                \n
                              1. <\/b> Every successful output is written anyway<\/span><\/li>\n
                              2. <\/b> None of the node outputs are written<\/span><\/li>\n
                              3. <\/b> Only Text outputs are written<\/span><\/li>\n
                              4. <\/b> Appian creates replacement process variables<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 2. None of the node outputs are written<\/b><\/p>\n

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

                                Appian handles node-output saving consistently to avoid leaving process data partially updated when an output fails. If one node output encounters an error that prevents it from writing its value to a process variable, none of the outputs from that node are written. This behavior helps protect process state from inconsistent partial updates. Developers should therefore validate output expressions and data-type compatibility carefully, particularly when one activity produces several important values. A failure in one output may prevent all expected process-variable changes from occurring, which can affect gateways or activities that execute later in the workflow.<\/span><\/p>\n

                                Question 196. A task is assigned to a group, but one expected user cannot see it. What should be checked FIRST?<\/b><\/p>\n

                                  \n
                                1. <\/b> Whether the application’s site name is dynamic<\/span><\/li>\n
                                2. <\/b> Whether the data store contains the task<\/span><\/li>\n
                                3. <\/b> Whether the user is actually a member of the group assigned to the task<\/span><\/li>\n
                                4. <\/b> Whether the task interface contains a map<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 3. Whether the user is actually a member of the group assigned to the task<\/b><\/p>\n

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

                                  When a User Input Task is assigned to a group, only users who belong to that group can normally see and work on the task. If a particular user cannot find the task, one of the first troubleshooting steps is therefore to verify the user’s group membership. Developers should also inspect any process-variable-driven assignment logic because an incorrect assignee value can route work to the wrong person or group. Another possibility is that the node has been configured as a quick task, which changes how it appears. Troubleshooting should begin with the assignment configuration before investigating unrelated application objects.<\/span><\/p>\n

                                  Question 197. A User Input Task is configured as a quick task. Where is that task typically exposed?<\/b><\/p>\n

                                    \n
                                  1. <\/b> As a related action on a process-backed record type<\/span><\/li>\n
                                  2. <\/b> Only in the application deployment log<\/span><\/li>\n
                                  3. <\/b> As a connected system<\/span><\/li>\n
                                  4. <\/b> Only through the Admin Console<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 1. As a related action on a process-backed record type<\/b><\/p>\n

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

                                    Quick tasks are intended to provide actions associated with process-backed records rather than appearing like ordinary assigned tasks in a user’s task list. Appian troubleshooting guidance notes that a User Input Task configured as a quick task appears as a related action on the corresponding process-backed record type. This distinction is important when users report that they cannot find an assigned task. The assignment itself may be correct, but the node’s Quick Task setting may be causing the work to appear in a different application context. Developers should confirm whether the task is meant to be a standard task or a quick task.<\/span><\/p>\n

                                    Question 198. A user receives a task but gets an error when attempting to open its form. Which issue should a developer investigate?<\/b><\/p>\n

                                      \n
                                    1. <\/b> Whether Health Check ran during business hours<\/span><\/li>\n
                                    2. <\/b> Whether the application contains enough constants<\/span><\/li>\n
                                    3. <\/b> Whether a rule input maps to a missing or invalid process value, or the interface contains an expression error<\/span><\/li>\n
                                    4. <\/b> Whether the site object has version history<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 3. Whether a rule input maps to a missing or invalid process value, or the interface contains an expression error<\/b><\/p>\n

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

                                      If a user can see a task but cannot open it successfully, the assignment itself has generally already occurred. The problem is more likely related to the task form or its data mappings. Appian recommends checking whether interface rule inputs map to valid parameters or process values, whether required data is unexpectedly null, and whether the interface evaluates successfully when realistic test data is supplied. Expression errors in the interface can prevent the form from rendering. Separating task-assignment problems from task-form rendering problems helps developers identify the correct troubleshooting path much more quickly.<\/span><\/p>\n

                                      Question 199. Which statement BEST describes the purpose of Start and End Events in an Appian process model?<\/b><\/p>\n

                                        \n
                                      1. <\/b> They define where a process begins and where workflow paths terminate<\/span><\/li>\n
                                      2. <\/b> They permanently store process-variable values<\/span><\/li>\n
                                      3. <\/b> They assign security groups to process activities<\/span><\/li>\n
                                      4. <\/b> They replace gateways used for routing<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 1. They define where a process begins and where workflow paths terminate<\/b><\/p>\n

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

                                        Start and End Events establish the boundaries of a process flow. A Start Event identifies where process execution begins, while an End Event identifies where a path completes. Between those events, activities perform human or automated work, gateways control routing, and connectors define the sequence between nodes. Properly structured process models make their entry points, business stages, routing decisions, and termination points easy to understand. Start and End Events are therefore structural workflow elements rather than storage or security mechanisms. Clear use of these events helps developers and business stakeholders interpret complex processes more easily during design, review, and troubleshooting.<\/span><\/p>\n

                                        Question 200. A senior developer is reviewing a legacy application that heavily uses CDTs, data stores, task forms, and complex process-variable mappings. What is the BEST overall approach before making structural changes?<\/b><\/p>\n

                                          \n
                                        1. <\/b> Delete all legacy data structures immediately and rebuild from scratch<\/span><\/li>\n
                                        2. <\/b> Review dependencies, validate data-store mappings, preserve compatible data structures, and trace process data flow before changing shared objects<\/span><\/li>\n
                                        3. <\/b> Change every CDT field name to follow a new naming standard<\/span><\/li>\n
                                        4. <\/b> Remove all node-input mappings and rely on implicit type conversion<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 2. Review dependencies, validate data-store mappings, preserve compatible data structures, and trace process data flow before changing shared objects<\/b><\/p>\n

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

                                          Legacy Appian applications often contain highly interconnected CDTs, database mappings, process variables, task forms, and expressions. A structural change to one shared data type can therefore affect many objects and potentially invalidate database mappings or running workflows. Senior developers should first perform dependency analysis, understand how information enters and leaves process nodes, review data-type compatibility, and validate the associated database schema. Backward-compatible changes should be preferred when practical. Modernization may eventually replace older patterns with newer Appian capabilities, but careful impact analysis and incremental changes are safer than deleting or rewriting heavily shared structures without understanding their dependencies.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full Appian ACD201 Exam Dumps and Practice Test Dumps. Question 181. What is a Custom Data Type (CDT) primarily used for in Appian? To define site navigation and branding To control user authentication settings To schedule process-model execution To represent a structured logical grouping of related data Correct Answer: 4. To represent a structured […]<\/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\/20712"}],"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=20712"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/20712\/revisions"}],"predecessor-version":[{"id":20713,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/20712\/revisions\/20713"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=20712"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=20712"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=20712"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}