Salesforce Certified Heroku Architect (Plat-Arch-206) Exam Topics and Questions
These Salesforce Certified Heroku Architect (Plat-Arch-206) exam topics are organized according to official exam domains to help candidates quickly verify coverage and focus on assessment rather than theory. Each domain is paired with topic-wise Salesforce Certified Heroku Architect (Plat-Arch-206) sample questions that reflect how objectives are tested in the actual exam. This structure enables efficient review, targeted self-assessment, and rapid identification of weak areas when preparing for the Salesforce Certified Heroku Architect certification exam.
Let's Practice Free Salesforce Certified Heroku Architect (Plat-Arch-206) Questions Aligned with Official Exam Topics
The Heroku Platform topic sets the foundation for everything else on this exam. Before you can reason about security, data, or enterprise architecture, you need a precise mental model of how Heroku actually runs code: what happens between a git push and a running dyno, how buildpacks transform source into a slug, and how the Elements Marketplace extends that model. Where candidates lose ground here is in the details they assumed they already knew. How Heroku Platform: is tested At...
The Heroku Platform topic sets the foundation for everything else on this exam. Before you can reason about security, data, or enterprise architecture, you need a precise mental model of how Heroku actually runs code: what happens between a git push and a running dyno, how buildpacks transform source into a slug, and how the Elements Marketplace extends that model. Where candidates lose ground here is in the details they assumed they already knew.
How Heroku Platform: is tested
At 10% of the exam, this topic contributes a modest share of items, but they tend to be the ones candidates dismiss during study and then regret in the room. Items focus on your ability to apply platform mechanics to a given scenario, not just recall them. Expect situations where you must choose between scaling strategies: when horizontal scaling via additional dynos is the right call versus when the problem is really about dyno size or concurrency configuration. The buildpack sub-topic appears in scenarios where a non-standard runtime or a multi-language app is involved, and items reward knowing how buildpack order affects slug composition. Marketplace items test whether you can select the right add-on for a constraint (latency, compliance, cost tier) rather than list what add-ons exist. Candidates lose marks by treating this topic as background knowledge and skipping deliberate review. The traps are in edge cases: what happens at the boundary of a free dyno's sleep cycle, or how Heroku Buttons affect the deployment lifecycle in a team context.
The ITExamsTopics practice test covers the full spread of platform mechanics items so you can spot exactly which corners of buildpack behaviour or scaling logic you have gaps in, rather than discovering them on exam day. A free demo is available for both the PDF and the practice test before you buy.
The question below targets a specific platform mechanic that often trips candidates who rely on general familiarity rather than precise knowledge.
A client has an e-commerce application that stores creditcard information. The application will run the production. Which security certification does the application need to meet?
Once you have the platform model straight, data architecture becomes the heaviest technical domain on the exam at 17%. This topic spans three distinct Heroku-managed data services plus the decision of when to reach outside them entirely. The failure mode here is breadth without depth: candidates who know what each service does but cannot prescribe the right one for a given constraint, replication requirement, or throughput profile will find this section punishing. β Heroku Postgres and operational patterns Heroku Postgres...
Once you have the platform model straight, data architecture becomes the heaviest technical domain on the exam at 17%. This topic spans three distinct Heroku-managed data services plus the decision of when to reach outside them entirely. The failure mode here is breadth without depth: candidates who know what each service does but cannot prescribe the right one for a given constraint, replication requirement, or throughput profile will find this section punishing.
β Heroku Postgres and operational patterns
Heroku Postgres is the most heavily tested data service on the exam, and the examinable surface is wider than basic connection and query patterns. Follower databases are a recurring scenario: you need to know when a follower is the right answer (read scaling, reporting workloads, disaster recovery) and when it is not (followers are eventually consistent and are not suitable for reads that must reflect the latest write). Dataclips appear in scenarios involving ad-hoc reporting and sharing query results with non-technical stakeholders without exposing credentials. Security sub-topics cover encryption at rest, credential rotation, and the difference between plan tiers in terms of compliance capabilities. Items reward knowing the operational boundary between what Heroku manages automatically and what the architect must configure explicitly.
β Kafka, Redis, and third-party add-ons
Apache Kafka on Heroku is tested in the context of asynchronous, streaming architectures. Items present a system with multiple producers and consumers and ask you to prescribe whether Kafka is appropriate and how it should be configured. The key distinction is between use cases that need durable, ordered, replayable message streams and those that need lightweight pub/sub or simple queuing, where Kafka would be over-engineered. Heroku Redis scenarios centre on caching, session storage, and rate limiting, with items that reward knowing when Redis is the right fit versus when a relational approach or Kafka would serve better. Third-party add-on and add-on sharing questions test the boundary conditions: when a native Heroku service falls short of a requirement and a Marketplace add-on fills the gap, and how add-on sharing works across apps in the same team or pipeline.
How Data: is tested
At 17%, Data generates more items than any other topic except Heroku Enterprise. The dominant item style is a scenario with a specific technical constraint (throughput, latency, consistency requirement, compliance tier, or cost ceiling) followed by a choice among data services or configurations. Items reward selecting the service that satisfies all stated constraints, not just the most obvious one. A common trap is choosing Heroku Postgres when Kafka is indicated, or Redis when Postgres is the better fit, because the candidate anchors on the service they know best. Follower database scenarios are particularly prone to a consistency trap: items reward recognising that follower reads are not guaranteed to be current. Third-party add-on items reward knowing when native services are insufficient, not just that alternatives exist. Candidates who have only studied each service in isolation, without practising cross-service trade-off decisions, tend to drop marks in the middle of this topic.
Working through a full bank of Data items under timed conditions is the most direct way to build the cross-service trade-off instinct this topic demands. The ITExamsTopics practice test and PDF both include items across all four data sub-topics, with a free demo available.
The question below places you in a scenario requiring a data service decision under a specific constraint. Work through it before reading on.
UniversalContainers (UC) has an on-permise application for reporting damage to their shipments. They want to migrate the application to Heroku. The damage reporting process includes uploading one or more pictures to the application which temporarily stores them onthe local system. After the report is submitted, a case is created in UC's Salesforce org for processing, amd the images are deleted from the file system. The application's configuration is read from environment variables that are specified in the system user's profile. The application writes its logs to rotating files using an open-source library. Which two recommendations should an Architect make to ensure that the application runs correctly on Heroku? Choose 2 answers.
Security overlaps with both the Data topic behind it and the Enterprise topic ahead, but it has a distinct focus: the architectural decisions that determine which Heroku runtime and network configuration a solution needs. At 15%, it is weighted equally with Architect Applications and Integrations, so it is not a topic you can skim. The penalty for weak preparation shows up in scenario items where two options both sound secure but only one satisfies the compliance or isolation requirement stated...
Security overlaps with both the Data topic behind it and the Enterprise topic ahead, but it has a distinct focus: the architectural decisions that determine which Heroku runtime and network configuration a solution needs. At 15%, it is weighted equally with Architect Applications and Integrations, so it is not a topic you can skim. The penalty for weak preparation shows up in scenario items where two options both sound secure but only one satisfies the compliance or isolation requirement stated in the stem.
How Security: is tested
This topic's three sub-topics map cleanly onto three item types. Certification and compliance items present a customer requirement (a named standard or regulatory context) and ask which Heroku capabilities or configuration choices achieve it. Items reward precision: knowing which features belong to which runtime tier, and which certifications Heroku's infrastructure supports versus which the architect must layer on top. Private Space Peering and VPN items test your ability to choose the right network connectivity model for a given topology. The trap is selecting VPN when peering is appropriate or vice versa based on surface-level similarity; items reward understanding the directional and routing differences between the two. Common Runtime versus Private Space Runtime items are the most scenario-dependent: the decision turns on isolation requirements, egress control, compliance mandates, and latency to other services. Candidates lose marks by treating Private Spaces as always superior; items reward matching runtime choice to the stated requirement, not defaulting to the more expensive option.
Security items are easier to misread under time pressure than almost any other topic. Seeing a variety of Private Space and compliance scenarios in the ITExamsTopics practice test before the exam helps you build the pattern recognition to slow down at the right moment. Demo available free.
The question below turns on a runtime or network configuration decision. Commit to an answer before checking.
Heroku Enterprise is the single largest topic on this exam at 28%, which means roughly one in four items you see will come from here. The topic covers the features that distinguish Enterprise from standard Heroku: Private Spaces, Heroku Shield, Enterprise Teams, and the networking decisions that go with them. Candidates who treat this as a repeat of the Security topic lose marks. Enterprise is about governance, organisational architecture, and the features that change what a team can build and...
Heroku Enterprise is the single largest topic on this exam at 28%, which means roughly one in four items you see will come from here. The topic covers the features that distinguish Enterprise from standard Heroku: Private Spaces, Heroku Shield, Enterprise Teams, and the networking decisions that go with them. Candidates who treat this as a repeat of the Security topic lose marks. Enterprise is about governance, organisational architecture, and the features that change what a team can build and control, not just how securely.
β Private Spaces, networking, and the Common Runtime choice
Private Spaces appear again here, but the Enterprise angle is different from the Security topic's runtime comparison. Enterprise items focus on when Private Spaces change what an organisation can build at scale: dedicated runtime capacity, internal routing between apps in the same space, and the implications for multi-region architectures. Networking items test your ability to choose between Private Spaces and the Common Runtime for a given enterprise workload, weighing factors like inter-app latency, egress requirements, and cost profile across a large app portfolio. The distinction from the Security topic is that Enterprise items tend to involve multiple apps, multiple teams, or organisational policies rather than a single app's isolation requirement. Items reward knowing the specific networking capabilities that are only available inside a Private Space.
β Heroku Shield and compliance architecture
Heroku Shield is the compliance-focused layer of the Enterprise tier, and items here are more specific than the general compliance items in the Security topic. You need to know which compliance frameworks Shield is designed to support, what Shield adds to a standard Private Space, and which features are Shield-specific versus available in non-Shield Private Spaces. Items reward drawing the line between what Shield provides automatically and what the architect must still configure or enforce. A common trap is assuming that running in a Shield Private Space satisfies a compliance requirement by itself; items reward recognising that certain architectural choices remain the architect's responsibility regardless of the runtime tier.
β Enterprise Teams and organisational governance
Enterprise Teams items are the most organisational of the exam. They test your knowledge of how teams are structured, how access is controlled, and how pipelines and app ownership work in an Enterprise context. The examinable territory includes the difference between team-level and space-level permissions, how apps are shared or transferred across teams, and how Enterprise Teams change the collaboration model relative to standard Heroku teams. Items reward knowing where the governance boundaries sit: what a team admin can and cannot do, and what requires an Enterprise account-level action. Candidates who have only used Heroku in small-team contexts tend to underestimate how much of this topic turns on organisational hierarchy rather than technical configuration.
How Heroku Enterprise: is tested
At 28%, this topic shapes your result more than any other. Items are predominantly scenario-based, presenting an organisation with a set of requirements (compliance mandate, team structure, networking constraint, app portfolio size) and asking which Enterprise features or configurations satisfy them. The dominant trap is conflating Shield with Private Spaces, or Private Spaces with Enterprise Teams: each is a distinct layer, and items reward knowing exactly which layer addresses which requirement. A second trap is over-specifying: choosing Shield when a standard Private Space is sufficient, or recommending Enterprise Teams features for a problem that standard access controls already solve. Items reward the minimum sufficient solution, not the maximum available one. Candidates also drop marks on networking items by applying Security topic reasoning (single-app isolation) to Enterprise scenarios that involve multiple apps and organisational routing policies. Study the feature boundaries precisely, not just the feature names.
With 28% of the exam here, a gap in Enterprise knowledge costs more than a gap anywhere else. The ITExamsTopics practice test lets you run through Enterprise items alone to check your coverage of Shield, Teams, and Private Spaces before sitting the real exam. Free demo included.
The question below presents an Enterprise scenario requiring you to select the right feature or configuration. Read the constraints carefully before answering.
After the organisational focus of Heroku Enterprise, this topic returns to technical architecture, specifically to the principles and patterns that govern how well-structured apps are built on Heroku. At 15%, it carries the same weight as Security and Integrations. The two sub-topics are not independent: the twelve-factor methodology and Kafka-based microservices orchestration both reflect a philosophy about how services should be decomposed, configured, and coupled. Candidates who know the theory but cannot apply it to a given architecture diagram will...
After the organisational focus of Heroku Enterprise, this topic returns to technical architecture, specifically to the principles and patterns that govern how well-structured apps are built on Heroku. At 15%, it carries the same weight as Security and Integrations. The two sub-topics are not independent: the twelve-factor methodology and Kafka-based microservices orchestration both reflect a philosophy about how services should be decomposed, configured, and coupled. Candidates who know the theory but cannot apply it to a given architecture diagram will find this topic harder than expected.
How Architect Applications: is tested
Items in this topic present an existing or proposed architecture and ask whether it conforms to twelve-factor principles, or ask you to prescribe changes that would make it conform. The twelve-factor methodology is not tested as a list to recite: items reward applying specific factors to a scenario. The most frequently tested factors involve configuration (environment variables versus hard-coded values), process (stateless dynos), and backing services (treating attached resources as interchangeable). Knowing which factor a given architectural flaw violates is the skill items reward, not naming the factors in order. Kafka orchestration items present a microservices topology and ask how an orchestration layer should be designed: which service owns the topic, how consumers are grouped, and what happens to ordering guarantees when partitions are involved. Candidates lose marks by treating Kafka as a simple message queue rather than understanding its role in decoupling services at the architecture level. Precision about what each factor or Kafka pattern actually requires is what separates passing answers from plausible-sounding ones.
Twelve-factor and microservices items reward pattern recognition built through repeated exposure to varied scenarios. Checking your answers against the full ITExamsTopics question bank, available as a practice test or PDF, shows you which principles you are applying correctly and which you are misreading under pressure.
The question below applies one of this topic's core principles to a specific architectural scenario. Work out your reasoning before reading further.
The final topic ties Heroku to the broader Salesforce ecosystem, which is where many candidates on this exam actually work day to day. Familiarity with Heroku Connect or the Lightning Platform can be an advantage here, but it can also be a trap: the exam tests precise architectural knowledge, not general practitioner experience. At 15%, Integrations is as consequential as Security and Architect Applications, and the two sub-topics cover meaningfully different integration patterns that are not interchangeable. How Integrations: is...
The final topic ties Heroku to the broader Salesforce ecosystem, which is where many candidates on this exam actually work day to day. Familiarity with Heroku Connect or the Lightning Platform can be an advantage here, but it can also be a trap: the exam tests precise architectural knowledge, not general practitioner experience. At 15%, Integrations is as consequential as Security and Architect Applications, and the two sub-topics cover meaningfully different integration patterns that are not interchangeable.
How Integrations: is tested
Heroku Connect items are the more technically specific of the two sub-topics. Items reward knowing when bidirectional sync is appropriate versus one-directional, how External IDs prevent duplicate record creation during sync, and what happens when mapping configuration is incorrect. The External ID sub-topic is a reliable source of items that reward precise knowledge: candidates who understand only that External IDs exist, without knowing how they function in sync conflict resolution, will find these items difficult. Lightning Platform integration items test your ability to choose among available integration techniques (Heroku Connect, direct API calls, platform events, Canvas) based on the requirements stated in the scenario. Items reward selecting the technique that fits the stated latency, volume, and data model constraints, not the one the candidate uses most often in practice. A common mistake is recommending Heroku Connect for use cases that need real-time event-driven behaviour, where a platform event or direct API pattern would serve better. Read the scenario constraints before committing to an integration pattern.
Integration scenarios are easy to get wrong when you rely on day-to-day practice rather than deliberate exam preparation. The ITExamsTopics PDF and practice test cover both Heroku Connect and Lightning Platform integration items, and the free demo lets you sample the style before committing.
The question below tests your ability to prescribe the right integration pattern for a specific set of Salesforce and Heroku constraints.
Ready to Start Practicing?
Access all questions and start your exam preparation journey
Upgrade to Full Salesforce Certified Heroku Architect (Plat-Arch-206) Exam Questions π