Quiz Data-Architect: Salesforce Certified Data Architect

The correct answer is B. Create a required Lookup relationship to each of the three parent records.
The requirements point to three distinct relationship needs:
1. The Shipment record must always be related to a Product, a Sender, and a Receiver.
2. If any of those parent records are in use by a Shipment, they must not be deletable.
3. Each custom object must maintain its own sharing model.
Why B is correct:
A required Lookup relationship satisfies the need for Shipment to always reference each parent object. By marking the lookup fields as required, Salesforce ensures that a Shipment cannot be saved without a Product, Sender, and Receiver.
The second requirement, preventing deletion of parent records that are referenced by Shipment, is also supported by lookup relationships. If a parent record is referenced by a child record, Salesforce can block deletion depending on the relationship behavior and referential integrity settings.
Most importantly, lookup relationships preserve separate sharing models for each object. This is a key reason to choose Lookup instead of Master-Detail. Master-Detail would make the child object inherit the parent’s sharing model, which violates the requirement that each custom object must have separate sharing models.
Why the other options are incorrect:
A. Associate the Shipment to each parent record by using a VLOOKUP formula field.
VLOOKUP is not used to create record relationships. It is a formula function for retrieving values, not for enforcing required parent-child associations or deletion rules.
C. Create a Master-Detail relationship to each of the three parent records.
Master-Detail does enforce tight parent-child behavior, including restricting deletion of parent records when children exist. However, it also causes the child object to inherit the parent’s sharing model. That directly conflicts with the requirement for separate sharing models.
D. Create two Master-Detail and one Lookup relationship to the parent records.
This still introduces inherited sharing for the Master-Detail relationships, so Shipment would not have an independent sharing model. That makes this option invalid.
Key takeaway:
Use required Lookup relationships when you need:
- a mandatory parent reference
- protection against deleting referenced parent records
- separate sharing models for each object
So the best solution is B.

The correct answer is C.
Universal Containers needs to preserve the original creation date from the legacy CRM during a one-time migration. In Salesforce, the standard CreatedDate field is an audit field. Normally, Salesforce controls this field automatically and users cannot set it manually.
However, Salesforce provides a special capability called "Set Audit Fields upon Record Creation", which allows an authorized user to preserve system fields such as:
- CreatedDate
- CreatedById
- LastModifiedDate
- LastModifiedById
This is exactly what is needed for a migration where historical accuracy must be maintained.
Why C is correct:
- By enabling "Set Audit Fields" and granting the proper permission to the migration user, the loading process can populate the original creation date from the legacy system.
- This is the standard and supported way to preserve audit history during data loads.
- It is commonly used with data migration tools such as Data Loader or ETL tools during initial loads or one-time migrations.
Why the other options are incorrect:
A. After the data is migrated, perform an update on all records to set the original date in a standard CreatedDate field.
- Incorrect because CreatedDate is not editable after record creation.
- Salesforce does not allow updates to audit fields through normal record updates.
B. Create a new field on Contact object to capture the Created Date. Hide the standard CreatedDate field using Field-Level Security.
- This could store a date, but it does not meet the requirement to keep the original creation date in the standard system field.
- Hiding the standard field does not solve the migration requirement; it only hides it from users.
- Also, reports, automation, and system behavior would still rely on the standard CreatedDate.
D. Write an Apex trigger on the Contact object, before insert event to set the original value in a standard CreatedDate field.
- Apex triggers cannot set standard audit fields like CreatedDate.
- Salesforce protects these fields from being directly modified in Apex.
Key takeaway:
When migrating data and you need to preserve original system timestamps, use Salesforce's audit field setting feature with the appropriate permission. That is the supported method to load historical record creation dates accurately.

The correct answers are B and D.
Why B is correct:
Creating a trigger on Contact and adding an error to the record with a custom label is a valid approach because Apex triggers can enforce custom validation logic, such as checking whether the Birthdate__c field contains a future date. By using a custom label for the error message, the message becomes translatable through Salesforce Translation Workbench. This lets the architect both enforce the rule and support multiple languages.
Why D is correct:
Creating a validation rule and translating the error message with Translation Workbench is also a standard Salesforce solution. A validation rule can directly detect future dates in the custom Birthdate__c field, and the error text can be translated into different languages using Translation Workbench. This is the simplest declarative option and meets the requirement for translatable error messages.
Why the other options are incorrect:
A. Implement a third-party validation process with translate functionality.
This is unnecessary and not the standard Salesforce approach. Salesforce already provides native validation and translation tools, so a third-party solution is not needed.
C. Create a workflow field update to set the standard ErrorMessage field.
Workflow field updates cannot be used to display validation errors to users in this way. Workflow rules are not designed to block record saves with custom error messages, so this does not satisfy the requirement.
Summary:
The client needs both validation and translatable error messages. Salesforce can achieve this either through:
- Apex trigger with custom label-based error text
- Validation rule with translated error messages in Translation Workbench
Therefore, the correct answers are B and D.

The correct answer is C. Custom metadata records are deployable using packages.
Custom metadata types are designed to store configuration data that can be deployed as part of application metadata. This is one of their main advantages over custom settings. Because they are metadata, their records can be included in packages and moved between environments more easily through deployment tools and metadata APIs.
Why the other options are incorrect:
A. Custom metadata records are not copied from production to sandbox.
This is false. Custom metadata is typically copied to sandboxes along with other metadata during sandbox creation.
B. Custom metadata types are available for reporting.
This is not the key advantage here, and in general custom metadata types are not used the same way as standard reportable objects. Custom settings and custom metadata are both primarily meant for configuration, not reporting.
D. Custom metadata records are editable in Apex.
This is false. Custom metadata records are generally not edited directly in Apex at runtime. They are intended to be managed as metadata, not as runtime data records.
Why C is correct:
Custom settings are more like application data and are not as easily deployed as metadata records. Custom metadata types, on the other hand, can be packaged and deployed across orgs, making them especially useful for distributing configuration with managed or unmanaged packages.
So the main advantage is that custom metadata records are deployable using packages.

The correct answer is D. Create a custom object related to the Invoice object with a picklist field for the Type.
The requirement is to classify attachments by type, such as Purchase Order or Receipt, and then report on the number of attachments grouped by that type. This means the type value must be stored in a way that supports reporting and is flexible enough to relate each attachment to an invoice.
Why D is correct:
- A custom object related to the Invoice custom object can store the attachment classification data.
- By adding a picklist field for Type on that custom object, you can define values such as Purchase Order, Receipt, and other categories.
- Because the data is stored in a custom object with a relationship to Invoice, it can be included in reports and grouped by the Type field.
- This approach meets both requirements: categorization and reporting.
Why the other options are incorrect:
A. Add additional options to the standard ContentType picklist field for the Attachment object.
- The Attachment object does not support customizing the standard ContentType field in the way described.
- Even if it did, standard attachment handling is limited and not ideal for reporting by business-specific categories.
B. Add a ContentType picklist field to the Attachment layout and create additional picklist options.
- ContentType is not a field you simply add to a page layout as a customizable business field.
- Layout changes do not create reportable metadata in the way needed for this requirement.
C. Create a custom picklist field for the Type on the standard Attachment object with the values.
- The standard Attachment object cannot be extended with custom fields in the same way a custom object can.
- Also, standard attachments are not the best choice for structured reporting requirements.
Key architectural point:
When business requirements require classification and reporting, especially for data associated with records, using a custom object is usually the best design if standard objects do not support the needed reporting structure.
So the best solution is D.

The correct answers are C. Bulk API limitations on picklist fields and D. Standard list view inline editing.
Here’s why:
The scenario describes a legacy model with Conferences and Venues, where there are only 20 Venues but hundreds of thousands of Conferences each year. Because the number of Venues is very small, denormalizing the model into a single Conference object with a Venue picklist is a reasonable design choice. However, the architect should consider the functional and operational impacts of using a picklist in place of a relational model.
Why C is correct: Bulk API limitations on picklist fields
When loading or updating large volumes of Conference records, the data will likely be moved via Bulk API or similar data-loading tools. Picklist fields can introduce challenges because:
- The values must already exist in the picklist definition.
- Data loads can fail if incoming values do not exactly match allowed picklist values.
- Managing picklist values becomes important when doing high-volume imports or integrations.
- If the Venue values change, data loads and integrations may need updates.
Since the organization creates hundreds of thousands of Conferences per year, bulk data operations are a major consideration. A Venue picklist means bulk processes must conform to picklist constraints.
Why D is correct: Standard list view inline editing
Using a picklist for Venue makes it easier for users to edit Conference records directly in list views, including inline editing, because picklists are natively supported and controlled in Salesforce UI.
This matters in a denormalized design because:
- Users can quickly update the Venue field without opening each record.
- The small number of venues makes picklist selection practical.
- Inline editing can improve usability for large sets of records.
Why A is not correct: Limitations on master-detail relationships
This would matter if the architect were considering a relational design using master-detail, but the question asks about denormalizing into a single object with a picklist. Since the design is intentionally removing the relationship, master-detail limitations are not the key concern.
Why B is not correct: Org data storage limitations
Storage is always worth considering, but denormalizing into a single object with a picklist does not inherently create a major storage concern beyond what already exists for Conference records. The question is focused on the implications of replacing a related Venue object with a picklist, and storage is not the primary issue here.
Summary
A Venue picklist is a good fit because there are only 20 Venues, but the architect should think about:
- C. How bulk data operations interact with picklist constraints
- D. How users can manage records efficiently with standard list view inline editing
So the correct answers are C and D.

The correct answers are B and D.
The question is about improving the performance of SOQL queries on a custom object Order__c that has a large volume of records and many fields. In Salesforce, query performance is mainly affected by how efficiently the database can locate the requested rows and how much data it has to read.
Let’s review the options:
B. Work with Salesforce Support to enable Skinny Tables.
Correct.
Skinny tables are custom, database-level tables created by Salesforce Support to improve query performance for objects that have a lot of fields and are queried frequently. They can contain a subset of fields from one or more related objects, reducing the amount of data the database must scan and retrieve.
This is especially useful when:
- the object has many fields,
- queries often access the same fields,
- and performance is impacted by large object size or joins.
Since Order__c has about 50 fields and is expected to grow significantly, skinny tables can help improve read performance.
D. Make the queries more selective using indexed fields.
Correct.
Selective queries are one of the most important ways to improve SOQL performance. If a query uses indexed fields in the WHERE clause, Salesforce can locate matching rows much more efficiently instead of scanning a large portion of the table.
Examples of indexed fields include:
- Id
- CreatedDate
- certain standard fields
- external IDs
- unique fields
- custom fields indexed by Salesforce Support
Because Order__c is expected to have a large and growing volume of records, making queries selective is critical for performance.
Why the other options are incorrect:
A. Use SOQL queries without WHERE conditions.
Incorrect.
A query without a WHERE clause retrieves all rows from the object. On a large object like Order__c, this would be inefficient and likely slow. It would worsen performance, not improve it.
C. Reduce the number of triggers on Order__c object.
Incorrect.
Reducing triggers may improve data modification performance, such as insert, update, or delete operations. However, the question specifically asks about improving the performance of SOQL queries that retrieve data from the Order__c object. Triggers do not directly make read queries faster.
Key takeaway:
For large Salesforce objects, query performance is improved by:
- using selective filters on indexed fields
- reducing the amount of data scanned or returned
- and, in some cases, using skinny tables for read optimization
Final answer: B and D

The correct answer is A. Create a picklist field, values sorted alphabetically.
Universal Containers needs a field on Opportunity to track shipping status, and the status can only have 10 possible values. This is a classic use case for a picklist.
Why A is correct:
- A picklist restricts users to a predefined set of valid values.
- This improves data quality because users cannot enter arbitrary text or misspell status values.
- It is simple and efficient for a field with a small, fixed set of values.
- Since the values are stored directly on the Opportunity record, there is no relationship created to another object, so it avoids any relationship-related skew concerns.
Why the other options are not the best choice:
B. Create a Master-Detail to custom object ShippingStatus c.
- Master-detail is meant for tightly coupled parent-child relationships.
- Shipping status is not really a child record that should be owned by Opportunity.
- It adds unnecessary complexity and could introduce unwanted roll-up and ownership behavior.
- It is not appropriate for a simple fixed list of 10 statuses.
C. Create a Lookup to custom object ShippingStatus c.
- A lookup would require managing 10 status records in a separate custom object.
- This is overkill for a small, fixed set of values.
- It also introduces a relationship where none is needed, adding complexity.
- While lookup relationships do not cause data skew by themselves, this design is less efficient than a picklist for a controlled set of values.
D. Create a text field and make it an external ID.
- A text field does not enforce allowed values, so users could enter inconsistent data.
- This hurts data quality.
- An external ID is intended for integration and record matching, not for controlling a status value list.
Why “sorted alphabetically” matters:
- While sorting the picklist alphabetically is not required for correctness, it helps usability.
- It makes the list easier for users to scan and select from, which further supports data quality.
Key takeaway:
When you need a small, fixed set of valid values on a record, a picklist is usually the best choice. It ensures consistency, is simple to use, and avoids unnecessary relationship complexity.

The correct answers are B and C.
Here is why:
The requirement has four key parts:
1. Track changes to 10 text fields on Contact
2. Capture who made the change
3. Capture when the change was made
4. Capture the old and new values
5. Be able to report on these changes in Salesforce for the past 3 months
Let’s evaluate each option.
Option A: Create a workflow to evaluate the rule when a record is created and use field update actions to store previous values for these ten fields in ten new fields.
This is not a good fit.
Why not:
- Workflow field updates do not capture historical change data in a way that supports auditing.
- Workflow rules are not designed to store who changed the field or the exact old and new values over time.
- This approach only copies values into fields on the same record, which means you lose change history over multiple updates.
- It also does not provide a proper report of changes over the last 3 months.
So A does not meet the requirement.
Option B: Write an Apex trigger on Contact after insert event and after update events and store the old values in another custom object.
This can meet the requirement.
Why:
- An Apex trigger can compare old and new values using Trigger.old and Trigger.new.
- It can capture:
- which field changed
- the old value
- the new value
- the user who made the change
- the time of the change
- By storing this information in a custom object, you can create custom reports on the change records.
- You can also filter the report for changes made in the last 3 months.
This is a valid custom auditing solution.
Option C: Turn on field Contact object history tracking for these ten fields, then create reports on contact history.
This also meets the requirement.
Why:
- Field History Tracking is specifically designed to track field changes.
- It automatically captures:
- the field name
- old value
- new value
- who made the change
- when the change happened
- Contact history data is reportable in Salesforce through standard history reports.
- Since the requirement is for the past 3 months, history tracking works well because history records are stored and can be filtered by date.
This is the standard Salesforce solution for auditing field changes.
Option D: Create a Contact report including these ten fields and Salesforce Id, then schedule the report to run once a day and send email to the admin.
This does not work.
Why not:
- A standard report shows current data only, not change history.
- Scheduling the report just sends snapshots of the current values.
- It does not tell you who changed the field, when it changed, or what the old value was.
- It does not provide true change tracking.
So D does not satisfy the requirement.
Final answer:
B and C
Short summary:
- B is a custom solution using Apex and a custom object to store detailed change history.
- C is the native Salesforce solution using Field History Tracking and history reports.
If you want, I can also explain why field history tracking has limits and when Apex is the better choice.

Option A is correct.