Quiz ARC-300: Salesforce Architect B2C Commerce Solutions

The correct answers are B, D, and E.
When customers are seeing incorrect pricing on a Product Detail Page right after a site goes live, the Architect should first investigate the most likely platform-level causes related to data availability and presentation. In this scenario, the three best places to begin are:
B. Check the Quota Status page
This helps determine whether the site has exceeded any platform quotas or limits that could affect pricing behavior, data loading, or page rendering. If a quota has been reached, some parts of the site may not behave as expected, including pricing updates or pricing-related services.
D. Check that there was not an error during replication
In a production deployment, pricing data often depends on successful replication of catalog or pricing information. If replication failed or was incomplete, some customers may be seeing outdated or inconsistent pricing data. This is a strong candidate when the issue appears after going live.
E. Check that the cache is set correctly
Incorrect caching can cause customers to see stale pricing even when the underlying data is correct. If cache settings are wrong, some users may receive old price values instead of the latest production prices. This is one of the first things to verify for inconsistent PDP pricing.
Why the other options are not the best first checks:
A. Check Log Center
Logs are useful for deeper troubleshooting, but this is usually not the first place to start for a pricing inconsistency caused by deployment, replication, or caching issues. It is more of a secondary investigation step.
C. Check the Global Preferences to be sure the settings are correct
Global preferences may affect site behavior, but they are not the most likely first cause of some customers seeing incorrect pricing immediately after launch. The more direct initial checks are quotas, replication, and caching.
Summary:
For incorrect pricing after production deployment, the Architect should first check:
- Quota Status
- Replication errors
- Cache configuration
Therefore, the correct answer is B, D, E.

The correct answer is C. The new services must be manually exported from staging and imported into Production.
In Salesforce B2C Commerce, custom services are configuration artifacts that are not automatically promoted between environments by data replication or code replication in the same way that code or certain site data might be. When an architect creates new service definitions in Staging and the integration is ready to go live, those services need to be explicitly moved to Production.
Why C is correct:
- New services are typically created and tested in Staging first.
- Before launch, they must be exported from Staging and then imported into Production.
- This ensures the service configuration, endpoints, credentials references, and related setup are carried over properly.
Why the other options are incorrect:
A. Data Replication
- Data replication is used for certain data-related artifacts, not for moving new custom service definitions into Production.
- It does not handle this deployment requirement.
B. Site Import
- Site Import is used for importing site-specific content or configuration, but it is not the standard mechanism for promoting newly created services from Staging to Production in this scenario.
D. Code Replication
- Code replication is used to move code cartridges and application code.
- Services are configuration items, not code artifacts, so this is not the correct mechanism.
Key takeaway:
When integrating a new payment cartridge and creating new services for it, those services must be manually exported from Staging and imported into Production before launch.

The correct answer is C. 1500 visits per hour, 30000 page views per hour, and 375 orders per hour.
Here is why.
B2C Commerce load testing should be based on realistic peak traffic and projected growth, not just raw historic totals. The question says the client has forecasted 300% growth, but the best-practice target is still derived from the expected business volumes in the provided metrics, then adjusted to a sensible load-test target for the new site.
From the given data, the baseline traffic is:
- 1500 visits per hour
- 30000 page views per hour
- 375 orders per hour
These values already represent the appropriate load-test target set for the new B2C Commerce site.
Why the other options are not correct:
A. 15000 visits per hour, 300000 page views per hour, and 3750 orders per hour
This is 10 times the baseline and is far beyond the stated growth expectation.
B. 150000 visits per hour, 3000000 page views per hour, and 37500 orders per hour
This is 100 times the baseline and is unrealistic for the scenario.
D. 3000 visits per hour, 60000 page views per hour, and 750 orders per hour
This is double the baseline, but the question is asking for the correct target based on the provided metrics and best-practice interpretation, which matches option C.
So the best answer is C because it reflects the appropriate load test targets derived from the given historical data and forecast, without overinflating the expected traffic.

The correct answer is D.
Why D is correct
For a complex LINK cartridge, especially one that performs asynchronous synchronization between B2C Commerce and an external provider’s database, logging needs to meet two goals:
1. Allow troubleshooting in production
2. Avoid overwhelming logs with unnecessary noise
The best approach is:
- Use a cartridge-specific logger category
- Log backend asynchronous communication at info level
- Log all errors at error level
This is exactly what option D describes.
Why this is the best practice
1. Cartridge-specific logger
Using a logger category specific to the cartridge makes it easier to filter, search, and isolate log entries related to this integration. This is important in production because multiple cartridges and integrations may be running at once.
2. Info level for asynchronous communication
Info logs are appropriate for important business or system events that are useful for understanding the flow of synchronization, such as:
- basket update received
- shipping address sync started
- payment/billing change processed
- sync completed successfully
These logs provide enough visibility for troubleshooting without producing excessive verbosity.
3. Error level for failures
All failures should be logged at error level so production issues are easy to detect and alert on. This includes:
- failed API calls
- rejected payloads
- mapping or validation errors
- database synchronization failures
Why the other options are not as good
A. Report info level message for the back-end asynchronous communication between both systems. Report all errors at error level message.
This is incomplete because it does not specify a cartridge-specific logger category. Without that, troubleshooting can become difficult in a large codebase.
B. Report debug level message for the back-end asynchronous communication between both systems. Report all errors at error level message.
Debug is too verbose for production troubleshooting as the primary logging level. Debug logs are usually disabled in production and are intended for detailed development-time diagnostics.
C. Get logger for cartridge specific category. Report debug level message for the back end asynchronous communication between both systems. Report all errors at error level message.
This is better than A or B because it uses a cartridge-specific logger, but debug level is still not the right default for production troubleshooting. Info is more appropriate for important operational events.
Summary
Option D is correct because it combines:
- a cartridge-specific logger for easy log isolation
- info-level logs for important asynchronous sync events
- error-level logs for failures
That makes it the most suitable solution for production troubleshooting in a hosted checkout integration.

The correct answers are A. Circuit breaker is enabled and B. Service timeout is set.
When a service call happens on every visit to the product detail page (PDP), the application depends heavily on that service being available and responsive. In this kind of design, the service configuration should include safeguards to protect the user experience and the overall system stability.
A. Circuit breaker is enabled
A circuit breaker prevents repeated calls to a failing service when it is unavailable or behaving poorly. If the PDP makes a service call on every visit, a failing downstream service could quickly cause slow page loads or widespread errors. Enabling a circuit breaker helps stop continuous retries and allows the application to fail fast, improving resilience.
B. Service timeout is set
A timeout ensures that the application does not wait indefinitely for the service response. Without a timeout, a slow or stuck service could hold up the PDP response and degrade the user experience. Setting an appropriate timeout allows the system to recover gracefully and proceed with fallback behavior if needed.
Why the other options are not correct:
C. Service mock up call is configured
Mock calls are generally used in testing or development, not as a best practice for production service configuration. They do not improve runtime resilience for a real PDP service call.
D. Service logging is disabled
Logging may be useful for monitoring, troubleshooting, and auditing. Disabling logging is not a general best practice for service configuration and does not address availability or performance risks.
In summary, for a service called on every PDP visit, the architect should ensure that the service is protected against failures and delays by enabling a circuit breaker and setting a timeout.

The correct answer is B. Service Status from Business Manager.
The issue described is that customers can no longer proceed to checkout, and the architect suspects the custom inventory check against a third-party API is causing the failure. Since this check is enforced at the beginning of checkout, a problem there could block the checkout flow and redirect customers back to the basket page.
Service Status in Business Manager is the tool used to inspect the status and result of service calls, including custom services and external integrations. It can clearly show whether the inventory-check service is failing, timing out, or returning an unexpected response. That makes it the best choice to confirm whether the inventory check is the cause of the checkout issue.
Why the other options are not correct:
A. Sales Dashboard from Reports and Dashboards
This is useful for monitoring sales metrics and overall business performance, but it does not diagnose technical issues in the checkout flow or service calls.
C. Pipeline Profiler from Business Manager
Pipeline Profiler is used to inspect script execution and diagnose pipeline behavior, but it is not the most direct tool for confirming issues with a service call to a third-party API in this scenario.
D. Realtime Report from Reports and Dashboards
Realtime Reports provide near-live business data and trends, but they do not directly reveal whether a custom inventory validation service is failing.
So, Service Status is the clearest tool to confirm that the inventory check is causing the problem.

The correct answers are A and B.
In B2C Commerce, assigning different price books to different audiences is typically done through customer groups. A customer group can be associated with one or more price books, allowing the storefront to show the correct pricing for members of that group.
Why A is correct:
- The requirement is to support separate pricing for 50 customer pricing groups, 30 employee pricing groups, and 10 vendor pricing groups.
- The most direct design is to create matching customer groups for each of those pricing segments.
- Then assign the appropriate price books to each customer group.
So:
- 50 customer groups for customers
- 30 customer groups for employees
- 10 customer groups for vendors
This aligns directly with the requirement.
Why B is correct:
- Instead of creating many independent top-level customer groups, the design can use a hierarchy:
- One parent customer group for customers with 50 subgroups
- One parent customer group for employees with 30 subgroups
- One parent customer group for vendors with 10 subgroups
- This is still valid because the storefront can use customer group membership to determine which price books apply.
- Grouping the groups under a parent structure can make administration easier while still supporting the required pricing segmentation.
Why C is incorrect:
- Campaigns and promotions are used for marketing and discounting, not for directly setting base price books.
- They do not satisfy the requirement to assign applicable price books by customer segment.
Why D is incorrect:
- This reverses the relationship and uses promotions and campaigns in a way that does not match price book assignment.
- Again, promotions/campaigns are not the right mechanism for setting segmented price books.
Conclusion:
- To meet the requirement of customized pricing for those 90 distinct pricing segments, the Architect should model the segments using customer groups.
- Therefore, A and B are the correct choices.

The correct answer is C.
The problem described is a Cross Site Scripting (XSS) issue. XSS happens when user-controlled input, such as a search term, is inserted into a page without proper escaping or encoding. In this case, the "quick search" value is not escaped, which means an attacker could inject JavaScript into the page.
To fix this, the developer must ensure that the search phrase is properly encoded for the context in which it is being output. Since the value is being inserted into a script-related context, normal HTML escaping is not sufficient. It needs JavaScript block encoding.
Why C is correct:
- <isprint ... encoding="jsblock" /> applies JavaScript block encoding.
- This prevents special characters in the searchPhrase from being interpreted as executable JavaScript.
- It is the appropriate defense when output is being placed into a JavaScript context.
Why the other options are incorrect:
- A. Replace ' with double Quote
- This is not a proper security fix.
- Simply changing quotes does not prevent script injection and does not provide encoding.
- B. Use <isprint value="${searchPhrase}" encoding="jshtmlr" />
- This suggests an encoding type that is not the right one for a JavaScript block context.
- HTML encoding alone, or a mismatched encoder, would not fully protect against XSS in script content.
- D. Use <toprint value="${searchPhrase}" />
- This does not indicate any security encoding.
- Printing the value directly would leave the application vulnerable.
Key takeaway:
To prevent XSS, output encoding must match the context where the data is used. For JavaScript content, use JavaScript-specific encoding, which is why C is the correct solution.

The correct answer is C. Add an order token in the callback URL and match the token against the one stored on the order.
The core problem is that the notification controller is publicly exposed and can be called by an external service to mark an order as paid. If the callback URL contains only the order ID, then anyone who knows or can guess that order ID could potentially invoke the controller and falsely mark the order as paid. That creates an authorization vulnerability.
Why C is correct:
An order token is a secret, unpredictable value that is tied to a specific order. By including this token in the callback URL and validating it against the token stored with the order, the system ensures that only a legitimate notification from the payment service can complete the payment status update. This protects against unauthorized requests because knowing the order ID alone is not enough.
Why the other options are incorrect:
A. Add a customer number in the callback URL and match the customer number against the one stored on the order.
This is not sufficient because customer numbers are not secret. If an attacker knows the customer number or can infer it, they may still be able to call the callback. A customer number is an identifier, not a security credential.
B. Add HTTPS restriction to the controller start node.
HTTPS protects data in transit, but it does not authenticate the caller or prevent unauthorized access. An attacker can still send an HTTPS request to the endpoint. So this does not solve the authorization issue.
D. Add a session attribute and validate it on the callback.
A session attribute is generally not suitable for an asynchronous external callback. The external payment service will not share the user’s browser session, and the callback may occur long after the original session is gone. This makes it unreliable and inappropriate for securing this type of controller.
Summary:
The safest and most appropriate approach is to use a secret, order-specific token in the callback URL and verify it on receipt. That prevents unauthorized callers from marking orders as paid.

The correct answers are A and D.
Here is why:
A. The log information includes the customer's card name as it appears along with the credit card number (PAN), which violates PCI.
This is improper because PCI standards restrict storage or display of sensitive cardholder data. Logging the full cardholder name together with the primary account number (PAN) can expose protected payment information and create compliance risk. Even if the name alone is not highly sensitive, combining it with the full card number in logs is unsafe in a production environment.
D. The log information includes the order number and customer's email, which violates PCI.
This is considered improper in the context of this question because the log output is exposing customer-identifying information in production. In audit/logging scenarios, order numbers and email addresses can be used to correlate transactions and identify customers, which may be treated as sensitive operational/customer data. In the context of the exam question, this is one of the two problematic items in the log output.
Why the other options are incorrect:
B. The log information includes the customer's card CVV (card security code) and expiration date, which violates PCI.
While CVV is highly sensitive and should never be stored after authorization, the question’s correct set does not include this option. The exam likely expects you to identify the specific items shown in the log excerpt, and this option does not match the intended violations in the provided answer key.
C. Information logs should not be used in a production environment
This is false. Information-level logs are commonly used in production. The problem is not the existence of info logs themselves, but whether they contain sensitive data.
Summary:
The issue is that the production log is exposing data that should not be present in logs, especially payment-related and customer-identifying information. Therefore, the best answers are A and D.