If you searched for Backend Developer - SAP Cloud Application Programming Model Dumps, chances are you want to know one thing: am I actually ready? An answer list can’t tell you that, but a good scenario can. So here is the challenge. Below are six original CAP scenarios. Grab a notebook, commit to an answer for each one, write down why you chose it, and only then scroll to the answer key. Ready?
TL;DR
- Direct answer: Yes, you can test yourself with scenario-based CAP questions, and it is one of the quickest ways to find out which concepts you recognise but can’t yet apply.
- You will work through six independently written questions on CDS relationships, data initialization, service exposure, authorization, deployment and troubleshooting.
- These are original practice questions. They are not official SAP exam questions and not leaked content, and no practice set can promise a pass.
Why do scenario questions reveal knowledge gaps so well?
Recognition is easy; application is hard. You can read that a composition ties a child to its parent and nod along, then freeze when a scenario asks what should happen to the children when the parent is deleted. Scenarios close that gap because they force you to decide.
They also show you what kind of gap you have. When you miss a question, sort the miss into one of three buckets: a vocabulary gap (you didn’t know the term), a concept gap (you knew the term but not how it behaves) or a tooling gap (you understand it but don’t know the command or file location). Each bucket needs a different fix, and a bare score can’t tell you which one you’re in. Keeping a short error log with those three labels is our study advice, not an SAP requirement, but it makes revision far more targeted.
What does the C_CPE certification test?
The facts in this section come from the official SAP certification guide page, which was checked on 24 October 2026. SAP can change details at any time, so confirm them there before you book.
Verified on the official page
- The certification is SAP Certified - Backend Developer - SAP Cloud Application Programming Model, exam code C_CPE.
- It verifies core CAP skills for designing and building extension applications to existing SAP applications, specifically SAP S/4HANA Cloud, using side-by-side extensibility on SAP BTP.
- It is aimed at backend developers who work with CAP using Node.js/JavaScript or Java, Core Data Services and Fiori Elements.
- The assessment is system based, listed at three hours, available in English, with a listed pass score of 100%.
- The two listed topic areas are Data Modeling and Data Initialization (41-50%) and Service Exposure and Deployment (41-50%).
- SAP recommends its learning journey on building side-by-side extensions on SAP BTP and mentions a practice system inside that journey.
Our study advice (not from SAP)
Because the assessment is system based, treat the multiple-choice questions below as reasoning warm-ups rather than a replica of the real format. After each one, rebuild the scenario in a small CAP project and run it. We have also folded authorization and troubleshooting into the questions as supporting skills, since they come up constantly in real service and deployment work. That is an editorial choice, not SAP’s official blueprint.
Before you start: what these questions are
Every question below was written independently for this article. They are practice material, not official SAP exam questions and not leaked content, and their wording and difficulty may differ from the real assessment. The technical points were cross-checked against SAP’s public CAP documentation and SAP Learning material.
The rules are simple: one attempt per question, write your reasoning in a sentence, and don’t look anything up until you have committed to an answer.
The mock test: six CAP scenarios
Question 1: The order and its items
A shop model has orders and order items. The business rule says items only exist as part of an order, they are created together with the order in a single request, and deleting an order must delete its items.
entity Orders {
key ID : UUID;
items : ???;
}
entity OrderItems {
key ID : UUID;
parent : Association to Orders;
product : String;
quantity : Integer;
}
Which definition of items fits the rule?
A) Association to many OrderItems on items.parent = $self
B) Composition of many OrderItems on items.parent = $self
C) Association to Orders
D) Composition of one OrderItems
Question 2: The CSV file that never loads
namespace sap.demo.shop;
entity Authors {
key ID : UUID;
name : String;
}
entity Books {
key ID : UUID;
title : String;
author : Association to Authors;
}
A developer saves sample rows as db/data/Books.csv with the header ID,title,author. When the app starts, the data does not appear. What is the best fix?
A) Keep the file name and change the header to ID,title,author_ID.
B) Rename the file to demo.shop-Books.csv and change the header to ID,title,author_ID.
C) Rename the file to demo.shop-Books.csv and keep the header ID,title,author.
D) Move the file to test/data and change nothing else.
Question 3: Exposing books without exposing secrets
The database entity shop.Books has title, stock and an internal costPrice. Customers should be able to browse books through a service, must not see costPrice, and must not be able to change anything.
using sap.demo.shop as shop from '../db/schema';
service CatalogService {
// your definition here
}
Which definition does the job?
A) entity Books as projection on shop.Books; and hide the cost price field in the Fiori app.
B) @readonly entity Books as projection on shop.Books excluding { costPrice };
C) Delete costPrice from the database entity.
D) @cds.persistence.skip entity Books as projection on shop.Books;
Question 4: The read that suddenly fails
Assume a Products entity exists in the model.
@requires: 'authenticated-user'
service Main {
@restrict: [{ grant: 'WRITE', to: 'productmanager' }]
entity Products as projection on shop.Products;
}
During local development with mocked authentication, the sample user alice, who only has the role admin, sends a GET request to Products. What does she get?
A) 200 OK with the product list
B) 401 Unauthorized
C) 403 Forbidden
D) 404 Not Found
Question 5: From cds watch to the cloud
Your project runs on SQLite with mocked users during development. You now need to run it on SAP BTP, Cloud Foundry, with an SAP HANA Cloud database and real user authentication. Which approach follows the standard CAP route?
A) Run cds add hana, cds add xsuaa and cds add mta, assemble the archive with mbt build, then deploy with cf deploy.
B) Push the project as it is, because in-memory SQLite keeps data safely in production.
C) Keep the mocked authentication, because mocked users are created automatically on BTP too.
D) Run only cds add mta and mbt build, because CAP switches from SQLite to SAP HANA on its own without any HANA configuration.
Question 6: Works locally, 403 in the cloud
Your app is deployed and running. A developer signs in through the app router and opens the service, and gets a 403. Locally, the same request worked fine as alice. The model uses roles in @requires and @restrict. What is the most likely cause?
A) Mocked users like alice exist only in development, and the real user has not been assigned a role collection that contains the roles the model needs.
B) The CSV files in db/data were not deployed, so authorization fails.
C) A 403 always means the CAP server is down and the app router is returning a gateway error.
D) Authorization annotations are ignored in production, so roles cannot matter.
Answer key and reasoning
No peeking until you have written down all six answers. Done? Then check yourself below.
Answer 1: B
A composition expresses ownership. The items are contained in the order, so CAP can handle them as part of the same unit: they can be created through a deep insert with the order, and they are removed when the order is deleted.
Why the other options are incorrect
A is a plain association. It links the two entities but says nothing about ownership, so you can’t rely on the items being created or removed together with the order.
C points from Orders back to Orders. It has the wrong target and the wrong cardinality for a list of items.
D is a composition, but of one item, so it can’t model a list.
Answer 2: B
Two details matter. First, a CSV file name has to match the fully qualified entity name, which here means the namespace, a hyphen, then the entity name: sap.demo.shop-Books.csv. Second, the header must use the names of the generated columns. A managed association such as author produces a foreign key element called author_ID, so that is what the header needs.
Why the other options are incorrect
A fixes the header but leaves a file name that doesn’t match the entity.
C fixes the file name but keeps a header that refers to the association rather than its foreign key.
D is a location change, not a naming fix. test/data is meant for test data that is loaded in development only, whereas db/data is deployed in every environment, including production.
Answer 3: B
A service projection is where you shape the API. excluding { costPrice } keeps the element out of the service entirely, and @readonly disables create, update and delete through that entity.
Why the other options are incorrect
A only hides the field in one client. The service would still return costPrice to anyone who calls the API directly, so hiding it in the UI is cosmetic, not protection.
C would damage other consumers of the database model and destroy data you may need internally.
D tells CAP not to create a database artifact for the entity. It doesn’t restrict anything for callers, and it breaks the link between the service entity and its table.
Answer 4: C
Once an entity carries @restrict, only the privileges you list are granted. Here the only grant is WRITE for productmanager, which covers the modifying operations. Nobody has been granted READ, so even a plain GET is refused. Alice is authenticated, so this is not a 401. A 403 means the system knows who you are, but you are not allowed to do this.
Why the other options are incorrect
A assumes the service-level @requires is enough. It isn’t, once the entity has its own restriction.
B would mean Alice hadn’t been identified at all. With mocked authentication she has.
D is wrong because the entity and its endpoint exist. The request reaches the service and is refused.
A fix would be to add a second privilege, for example { grant: 'READ', to: 'authenticated-user' }, or a specific role if reading should be limited too.
Answer 5: A
SQLite is the low-cost stand-in for development, and SAP HANA Cloud is the production database. cds add hana prepares the project for it, cds add xsuaa configures XSUAA-based authentication and generates an xs-security.json, and cds add mta generates the mta.yaml deployment descriptor. mbt build assembles the archive (running the production CDS build as part of that), and cf deploy ships it to Cloud Foundry.
Why the other options are incorrect
B is wrong because in-memory SQLite is a development convenience, not a place to keep production data.
C is wrong because mocked authentication is for development only. In production, requests carry real tokens.
D is wrong because the production database has to be configured and bound. CAP doesn’t silently swap one database for another.
Answer 6: A
Mocked users such as alice and bob come with the development setup and are not suitable for production. In the cloud, the token comes from XSUAA, and the roles inside it come from role collections assigned to the real user. The roles your model refers to must exist in the XSUAA configuration (cds add xsuaa generates xs-security.json for this), the role collection must be assigned to the user in the BTP cockpit, and the user should sign out and in again so the new token carries the roles. If the cause isn’t obvious, check the application logs, for example with cf logs <app> --recent.
Why the other options are incorrect
B mixes up two unrelated things. Initial data has no influence on whether a role check passes.
C misreads the status code. A 403 means the request reached the application and the user was identified, but wasn’t permitted.
D is the opposite of the truth. The annotations are enforced in production, which is exactly why mocked users can’t stand in for real role assignments.
How to read your result
Don’t treat your count as a prediction. Look at where the misses cluster. Several misses on Questions 1 to 3 point to data modeling and service shaping; misses on 4 to 6 suggest working through authorization and deployment in a real project. Revisit the relevant documentation, rebuild the scenario, and then try again with fresh questions.
Common mistakes to avoid
- Shipping sample data in the production folder. Files in db/data are deployed everywhere. SAP’s own tutorial material warns that delivering files for tables that hold customer data can cause data loss in productive scenarios. Keep sample rows in test/data.
- Testing only with users who have roles. The predefined mock users make everything look fine. Define a user with no roles locally so you can see what a refused request really looks like before the cloud shows it to you.
- Debugging by guessing. Read the cds watch console output locally and the application logs in Cloud Foundry first. The error message usually names the exact problem.
- Memorising answers instead of the rule behind them. If you can only repeat an answer key, a small change in a scenario will catch you out. Make yourself state the rule in one sentence.
- Practising by recognition only. The official page describes a system-based assessment, so time spent actually writing, running and fixing CAP code is worth more than another round of reading.
Final revision checklist
☐ I can explain when to use a composition and when an association, and what happens to children on delete.
☐ I can name a CSV file for an entity inside a namespace and write foreign key headers correctly.
☐ I know which folder is deployed everywhere and which is for development only.
☐ I can shape a service with projections, excluding and @readonly.
☐ I can write @requires and @restrict rules and predict a 401 versus a 403.
☐ I can explain why SQLite and mocked users are development-only choices.
☐ I can add SAP HANA, XSUAA and MTA support, then build and deploy the archive.
☐ I have rebuilt each scenario in a real CAP project instead of only reading it.
☐ I have re-read the official certification page for the current format, topics and requirements.
Frequently asked questions
Are these official SAP C_CPE exam questions?
No. They were written independently for practice. They are not official SAP exam questions and not leaked content, and they may differ in style and difficulty from the real assessment.
Is the C_CPE assessment multiple choice?
The official certification page lists it as a system-based assessment. Check that page for the current format, because SAP can change it. This is why we suggest rebuilding every scenario hands-on after you answer it.
Which topics should I focus on?
The official page lists two topic areas: Data Modeling and Data Initialization (41-50%) and Service Exposure and Deployment (41-50%). Authorization and troubleshooting skills support both, which is why they appear in the questions above.
Can answer lists replace real preparation?
Unofficial question banks vary in accuracy and may not reflect the current assessment. Because the official format involves working in a system, understanding why something works matters more than remembering which option was correct.
How should I use practice questions like these?
Attempt each one before looking at the answer, write down your reasoning, log the type of gap each miss reveals, and then reproduce the scenario in a small project. Repeat with new material until you can explain every answer without hints.
Scenario practice works best when it sends you back to the documentation instead of away from it. Use these six questions to find your weak spots, fix them in a real CAP project, and keep practising with fresh material, such as the study resources on The Exam Questions. Whatever you use, remember that practice questions are a diagnostic tool, not a guarantee, and the official certification page remains the final word on format, topics and requirements.
