Why Study with PlanetCert?
The Latest Questions
Practice questions and exam topics aligned with the current exam objectives.
Detailed Explanations
Go beyond the answer. Master the material with comprehensive learning and professional explanations for every concept.

AI-Powered Insights
Personalized preparation guidance that adapts to your performance and identifies weak spots automatically.
Exam Information
Official specifications published by Sitecore
Exam Format
Registration
Validity
Skills this practice test covers
- Structure a solution into Helix Foundation, Feature and Project layers.
- Patch Sitecore configuration and control the order in which patch files load.
- Set up item-level and field-level language fallback, and decide when to enforce version presence.
- Serialize items with Sitecore Content Serialization and the Sitecore CLI.
- Query content with the ContentSearch API, LINQ and computed index fields.
- Build renderings with dynamic placeholders and rendering parameters that work in the Experience Editor.
Explore related topics
Sitecore-10-NET-Developer exam content
8 domains · 48 topics · 219 of 223 questions sorted by domain
Sitecore Structure & Platform18%28 questions
The largest competency covers how a Sitecore solution is organized and configured. Candidates apply Helix principles, plan multisite structures and control configuration through patch files.
Skills tested
- Place each module in the Foundation, Feature or Project layer.
- Keep dependencies flowing from Project to Feature to Foundation, never between features.
- Set up site definitions for a multisite solution with shared or separate content trees.
- Write patch files and control their load order with Layers.config.
- Use role-based configuration to apply settings per server role.
Questions by topic
- Helix Principles and Layers4
- Patch File Management5
- Helix Architecture Case Study4
- Helix Principles6
- Multisite Structures6
- Pipelines2
- Role-based Configuration1
System Administration for Developers13%30 questions
This competency covers the setup work around the code. Candidates install Sitecore, deploy it in containers, apply support packages and manage security.
Skills tested
- Install Sitecore with the Sitecore Install Assistant (SIA) and fix installation errors.
- Deploy and run Sitecore in Docker containers.
- Apply hotfixes and support packages in the right way.
- Manage users, roles and access rights with the Role Manager and the Security Editor.
- Trace access problems caused by role inheritance.
Questions by topic
- Role-based Configuration3
- Docker Container Deployment8
- User and Role Management8
- Performance and Health Monitoring4
- Workflow3
- Troubleshooting Security3
- Patch File Management1
Versioning and Language Fallback10%21 questions
Multilingual sites depend on this competency. Candidates manage numbered and language versions, and decide what a visitor sees when a translation is missing.
Skills tested
- Manage item versions and control which version gets published.
- Configure item-level and field-level language fallback.
- Set the language fallback chain for each site.
- Use enforced version presence to hide items that have no translation.
Questions by topic
- Language Fallback Configuration5
- Troubleshooting Language Fallback7
- Version Management4
- Language Fallback Behavior5
Item and Data Foundations13%28 questions
Sitecore content is a tree of items, and data templates define their fields. Candidates design templates, set standard values and move items between environments with serialization.
Skills tested
- Design data templates with template inheritance and template folders.
- Set standard values and insert options on templates.
- Configure module.json files for Sitecore Content Serialization.
- Push serialized items through a CI/CD pipeline to other environments.
Questions by topic
- Standard Values6
- Content Serialization4
- Template Validation Rules3
- Troubleshooting Data Integrity3
- Template Inheritance6
- Content Serialization and CI/CD4
- Workflow2
Sitecore API11%34 questions
This competency covers code that reads and changes content. Candidates retrieve and edit items through the Sitecore.Data API, choose the right database context and build renderings for MVC or headless sites.
Skills tested
- Retrieve items with the right item retrieval method for the task.
- Edit items safely with editing and locking, and check item security in code.
- Choose the correct database context for authoring and delivery code.
- Serve headless pages through the Layout Service and the ASP.NET Core rendering SDK.
- Work with media items through the Media API.
Questions by topic
- Item Retrieval Methods4
- Item Editing and Locking4
- API Best Practices7
- Layout Service API4
- Media API6
- Pipelines6
- Database Contexts3
Content Search10%25 questions
Content search answers queries from indexes instead of the database. Candidates configure Solr indexes, add computed fields and write LINQ queries with the ContentSearch API.
Skills tested
- Configure index configuration files and choose which fields to include or exclude.
- Add computed fields to an index.
- Write LINQ queries with search predicates, result filtering and facets.
- Troubleshoot indexing problems such as missing or out-of-date results.
Questions by topic
- Index Configuration7
- LINQ and Search API7
- Computed Index Fields6
- Troubleshooting Indexing4
- API Best Practices1
Rendering and Layout15%30 questions
This competency covers how pages are put together. Candidates set presentation details, use layouts and placeholders, and build components that authors can edit in the Experience Editor.
Skills tested
- Configure layouts, placeholders and placeholder settings in presentation details.
- Use dynamic placeholders to place the same rendering more than once on a page.
- Bind renderings to data sources and expose rendering parameters.
- Output fields with field renderers so they stay editable in the Experience Editor.
Questions by topic
- Data Sources4
- Field Renderers5
- Device-specific Layouts3
- Dynamic Placeholders7
- Experience Editor4
- Rendering Parameters6
- Layout Service API1
Personalization10%23 questions
Personalization changes content for each visitor. Candidates build rules from conditions and actions, track goals and campaigns, and test content variations.
Skills tested
- Build personalization rules in the Rule Set Editor from conditions and actions.
- Set up goals and campaigns to track visitor engagement.
- Plan content tests that compare variations of a component.
- Find out why a personalization rule does not fire.
Questions by topic
- Rule Set Editor8
- Testing Strategies5
- Troubleshooting Personalization6
- Rule Set Configuration4
Requirements
- No prerequisite exam is required.
- Recommended: a year or more of building Sitecore solutions.
- Recommended: solid C# skills and ASP.NET MVC on .NET Framework or .NET Core.
- Recommended: front-end basics in HTML, CSS and JavaScript, plus some SQL Server.
About the Sitecore-10-NET-Developer exam
Sitecore-10-NET-Developer is Sitecore's exam for .NET developers who build, configure and extend Sitecore 10 sites. Sitecore spreads the exam across eight competencies, from Helix architecture and patch files to the Item API, content search, renderings and personalization. The exam is closed book and runs on Kryterion Webassessor. Passing earns the Sitecore 10 .NET Developer Certification, and certified developers can open support cases with Sitecore.
The PlanetCert practice test covers all eight competencies, with many questions on the Sitecore API, renderings and system administration. Every answer has an explanation, which helps on questions about runtime behavior, such as which patch file wins or why a page shows text from a fallback language. For the troubleshooting questions on language fallback and indexing, Study Mode gives time to trace the cause through configuration. Ask Brainy AI Assistant to compare item-level and field-level fallback, or to find why a rendering cannot be edited in the Experience Editor.
How to earn the certification
- Earns
- Sitecore 10 .NET Developer CertificationProfessional
How to prepare for Sitecore-10-NET-Developer
- 1
Run Sitecore 10 locally
Install a Sitecore 10 instance in Docker containers or with the Sitecore Install Assistant. Most competencies are easier to learn on a working instance that can be broken and fixed.
- 2
Build one small Helix solution
Create Foundation, Feature and Project modules, one data template and one component. Serialize the items with the Sitecore CLI so they live in source control.
- 3
Test fallback with two languages
Add a second language and switch item-level and field-level fallback on and off. Note what a visitor sees each time, with and without enforced version presence.
- 4
Weight study toward the platform
Sitecore Structure & Platform is the largest competency, and Rendering and Layout comes next. Practise patch file load order and placeholder settings until the result of each change is predictable.
- 5
Rehearse closed book under time
The real exam is closed book, so take the practice test in Timed Mode with no documentation open. Ask Brainy AI Assistant about every API or configuration question that went wrong.
Start a timed Sitecore-10-NET-Developerrun
Sitecore's official preparation for this exam is the Sitecore 10 Developer eLearning Bundle.
Who Sitecore-10-NET-Developer is for
- .NET developers who build and maintain sites on Sitecore Experience Manager or Sitecore Experience Platform.
- Developers at companies that run Sitecore and need a certified developer or administrator to open support cases.
- Technical consultants and solution architects who design Sitecore solutions.
- DevOps engineers who run Sitecore in containers.
Typical job titles: Sitecore developer · .NET developer · Solution architect · Technical consultant · DevOps engineer
Sitecore-10-NET-Developer glossary
18 terms from the exam objectives and the vendor's official material, each defined in a sentence.
- Computed fields
- Index fields whose values code calculates at indexing time, instead of copying them from an item field.
- Dynamic placeholders
- Placeholders whose keys get a unique suffix, so one rendering can appear several times on a page with separate content.
- Enforced version presence
- An item setting that hides the item in any language where it has no version, even when fallback is on.
- Experience Editor
- Sitecore's in-page editing interface. Components must support it so authors can change content where it appears.
- Feature Layer
- The Helix layer for modules that each deliver one business feature. Feature modules do not depend on each other.
- Field-level fallback
- Filling a single empty field from the fallback language, while the other fields keep their own values.
- Foundation Layer
- The lowest Helix layer. It holds shared modules that the other layers build on.
- Item-level fallback
- Showing a whole item in a fallback language when it has no version in the requested language.
- Layout Service
- The Sitecore service that returns a page's layout and content as JSON for headless front ends.
- Patch file load order
- The order in which Sitecore applies configuration patch files. It decides which setting wins when two files change the same one.
- Project Layer
- The top Helix layer, where each site's layouts and page types bring the feature modules together.
- Rendering parameters
- Settings an author gives one use of a rendering, such as a display style, separate from its data source.
- Rule Set Editor
- The dialog where authors build personalization rules from conditions and actions.
- Sitecore CLI
- The command-line tool that runs serialization and other developer tasks against a Sitecore instance.
- Sitecore Content Serialization (SCS)
- The Sitecore 10 system that writes items to files, so content can go into source control and move between environments.
- Sitecore Install Assistant (SIA)
- Sitecore's guided installer, which sets up the prerequisites and a Sitecore 10 instance step by step.
- Standard values
- Default field values set on a data template, which every item based on that template inherits.
- Template inheritance
- A data template reusing the fields of its base templates, so shared fields are defined only once.