IT Certifications · AP-225

Salesforce Heroku Developer AP Exam Practice Test

Heroku development involves building and operating applications on a platform where dynos run application processes and releases can include deployment tasks. The practice bank uses scenarios about handling slow web requests, scaling web capacity, diagnosing startup failures, persisting uploaded files, and running scheduled work. It also touches on database migrations, transient service errors, and protecting customer information during troubleshooting.

Exam overview

Exam providerSalesforce
Exam codeAP-225
CategoryIT Certifications

About the Salesforce Heroku Developer AP Exam

Heroku application work requires matching process design to workload: long-running calculations may need to move out of request handling, while additional web processes can increase capacity for applications that support horizontal scaling. Operational decisions include inspecting running dynos and using application logs to investigate startup behavior. Developers also need to account for the platform’s ephemeral dyno filesystem when choosing storage for user uploads, and to schedule recurring tasks without leaving an idle process waiting. Deployment scenarios involve understanding what happens when a release-phase migration fails and using backward-compatible schema changes to reduce disruption across application versions. For dependencies that fail temporarily, resilient client behavior can include bounded retries with appropriate backoff. Troubleshooting private-data applications also calls for limiting sensitive information in logs and diagnostic output.

Sample Practice Questions

Review a selection from this exam's published US Practice Tests practice bank.

Question 1

A Heroku app's web process receives a request that takes several minutes to complete because it performs a lengthy report calculation. What design change generally improves responsiveness for other users?

  1. APerform the calculation synchronously in the web process and increase its timeout
  2. BMove the calculation to a background worker and return a response promptly
  3. CStore the calculation result in a dyno-local file and block until it is read
  4. DRun the calculation during application startup
Show answerCorrect answer: B

Long-running work can tie up a web process and delay other requests. A background worker can process the task asynchronously while the web process responds promptly, often with a status or acknowledgment.

Question 2

A developer wants to see which dyno types are currently running for a Heroku app. Which CLI command is most appropriate?

  1. Aheroku ps
  2. Bheroku config
  3. Cheroku domains
  4. Dheroku pipelines
Show answerCorrect answer: A

`heroku ps` displays process and dyno information for an app. Configuration, domain, and pipeline commands provide different kinds of information.

Question 3

A service has a sudden increase in incoming web traffic, and its application is designed to run multiple identical web processes. Which action most directly increases its web request capacity on Heroku?

  1. AScale the web process to more dynos
  2. BIncrease the number of Git branches
  3. CAdd more configuration variables
  4. DRename the application
Show answerCorrect answer: A

Scaling the web process to additional dynos provides more running instances to handle concurrent requests, subject to the app’s architecture and platform limits. Git branches, configuration-variable count, and app naming do not add request-serving capacity.

Question 4

An app needs to store uploaded user files so they remain available after its dyno is restarted or replaced. Which approach is most appropriate?

  1. AWrite the files to the dyno's local filesystem and keep them in the app directory
  2. BStore the files in an external object-storage service and keep references in the app
  3. CSave the files in a temporary directory and rely on it across deployments
  4. DEmbed each file in the application's source repository
Show answerCorrect answer: B

Heroku dyno filesystems are ephemeral: changes made at runtime are not a durable place for user uploads. External object storage is designed to persist files independently of dyno lifecycle.

Question 5

An application has a release phase that runs a database migration. The migration fails during a deployment. What is the expected deployment outcome?

  1. AThe new release is promoted as successful, and the failed migration is retried by each web dyno
  2. BThe release is not promoted as a successful release, so the new code is not activated as the current release
  3. CThe platform silently skips the release phase and activates the new code
  4. DThe migration is automatically rolled back by the database in every case
Show answerCorrect answer: B

A failed release-phase command causes the release to fail rather than being marked as a successful active release. Whether database changes can be rolled back depends on the migration and database; automatic rollback should not be assumed.

Question 6

A developer's application works locally but exits shortly after starting on Heroku. Which diagnostic source is the most direct first step for seeing application startup messages and errors?

  1. AThe application's Heroku logs
  2. BThe repository's list of branches
  3. CThe browser's bookmark history
  4. DThe database schema diagram
Show answerCorrect answer: A

Heroku logs show output from application processes and platform events. Reviewing recent logs is a practical first step when investigating a failed or short-lived process.

Question 7

A Heroku application processes private customer information. Which practice best supports minimizing exposure during troubleshooting?

  1. ALog complete request bodies and authentication tokens for every request
  2. BAvoid logging sensitive values and restrict access to operational logs
  3. CCopy production logs into a public issue tracker
  4. DKeep logs indefinitely without reviewing retention needs
Show answerCorrect answer: B

Logs can contain sensitive information and are often accessible to operational personnel or systems. Redacting sensitive values and limiting access and retention reduces unnecessary exposure while preserving useful diagnostic information.

How to use this practice test

The free practice session presents up to 20 random questions from the available 50-question bank. Answer the scenarios, then use the results to identify areas to revisit, such as dyno operations, release behavior, persistence, or request handling. The questions are practice material, not a measure of official exam coverage.

Preparation tips

  • Trace the difference between web request handling and background work; identify when a lengthy calculation should run outside the request-response path.
  • Practice using Heroku CLI and logs to inspect dyno processes and diagnose startup errors, while avoiding exposure of credentials or customer data.
  • Design storage for uploaded files around dyno filesystem ephemerality; distinguish persistent object storage from temporary local files.
  • Review safe deployment patterns: understand release-phase migration failures and use additive, backward-compatible schema changes during rolling deployments.
  • For transient dependency failures, consider bounded retries and backoff, and choose a scheduling approach that does not require an idle dyno to wait.
Official sourceOfficial exam page ↗