📖 About this Domain
This domain focuses on the essential tools that support the Sitecore development lifecycle. It covers installation automation, item serialization, and integration with integrated development environments (IDEs). Understanding these tools is fundamental for efficient development and deployment workflows.
🎓 What You Will Learn
- You will learn to use the Sitecore Installation Framework (SIF) for repeatable, scripted installations of Sitecore environments.
- You will learn how the Sitecore Command Line Interface (CLI) and Sitecore Content Serialization (SCS) manage items between a database and the file system.
- You will learn about the Sitecore for Visual Studio (SVS) extension for browsing the content tree and generating models directly in your IDE.
- You will learn the core principles of serialization for tracking database item changes in source control.
🛠️ Skills You Will Build
- You will build the skill to automate Sitecore topology setup using SIF PowerShell cmdlets.
- You will build proficiency in synchronizing Sitecore items using SCS commands like pull and push via the Sitecore CLI.
- You will build the ability to generate strongly-typed C# models from Sitecore templates using SVS or other code generation tools.
- You will build the foundational skill of integrating item serialization into a source control strategy for team-based development.
💡 Top Tips to Prepare
- Practice a complete on-premise installation using SIF to understand its configuration files and dependencies.
- Install the Sitecore CLI, log in to an instance, and perform serialization operations on a sample module.
- Use Sitecore for Visual Studio to connect to an instance, view items, and generate a model for a custom template.
- Examine the JSON configuration files for an SCS module to understand how rules and paths define the scope of serialization.
📖 About this Domain
This domain covers the process of transferring content from the Master database to one or more web databases, making it live. It focuses on the mechanisms, modes, and APIs that control how content items and their versions are published. Understanding publishing is critical for managing content delivery environments.
🎓 What You Will Learn
- You will learn the distinctions between publishing modes: Incremental Publish, Smart Publish, and Republish.
- You will learn how to configure publishing targets to push content to different web databases.
- You will learn to apply publishing restrictions on items and versions to control content visibility.
- You will learn to use the Sitecore Publishing API, including the PublishManager class and PublishOptions, for programmatic control.
🛠️ Skills You Will Build
- You will build the skill to execute and manage publishing operations from the Sitecore client interfaces.
- You will build the ability to programmatically trigger publishing jobs for content automation.
- You will build the competence to diagnose and resolve common publishing issues, like missing items on a CD server.
- You will build the skill to configure and manage multiple publishing targets for complex delivery architectures.
💡 Top Tips to Prepare
- Practice initiating each publishing mode to understand its performance and database impact.
- Inspect the web database directly after a publish operation to confirm expected item and version states.
- Write a simple agent or controller that uses the PublishManager API to publish an item programmatically.
- Experiment with setting publishing restrictions on an item and its versions, then observe the results after a Smart Publish.
📖 About this Domain
This domain covers Sitecore's presentation layer, focusing on how content items are visually rendered on a web page. It details the core concepts of layouts, renderings, and placeholders which form the basis of component-based architecture in Sitecore. Understanding presentation details is critical for assembling pages and enabling content authoring.
🎓 What You Will Learn
- You will learn how layouts define the main HTML structure and how renderings, such as View Renderings and Controller Renderings, inject content into that structure.
- You will learn to configure presentation details on items and Standard Values, binding specific renderings to placeholders using the Layout Details dialog.
- You will learn the difference between static and dynamic placeholders and how to implement dynamic placeholders for repeatable component scenarios.
- You will learn about rendering datasources, allowing components to be content-agnostic and reusable across the solution.
🛠️ Skills You Will Build
- You will build the skill to construct a full web page by defining a layout and assembling various renderings within its placeholders.
- You will build proficiency in creating and configuring different types of renderings, including setting datasources and rendering parameters.
- You will build the ability to develop components that are fully editable within the Experience Editor, utilizing features like Field Renderers.
- You will build a strong understanding of Sitecore's MVC implementation, including routing, controllers, and passing models to views.
💡 Top Tips to Prepare
- Master the distinction between Shared Layout and Final Layout in Presentation Details and understand how layout deltas are applied.
- Practice creating rendering parameter templates to allow content authors to modify component behavior without developer intervention.
- Implement a page with nested renderings using dynamic placeholders to fully grasp their syntax and functionality.
- Build a Controller Rendering from scratch, including the controller logic, a repository, a view model, and the corresponding CSHTML view.
📖 About this Domain
This domain covers the core Sitecore Item API for programmatic content manipulation. You will focus on CRUD operations and the fundamental structure of items within the Sitecore content tree.
🎓 What You Will Learn
- Utilize the Sitecore.Data.Items.Item class and Sitecore.Data.Database methods for all item interactions.
- Differentiate between item retrieval using string paths versus Sitecore.Data.ID objects and understand best practices.
- Implement create, read, update, and delete (CRUD) operations on items using the correct API calls.
- Manage item versioning programmatically, including adding new versions and accessing specific version data.
🛠️ Skills You Will Build
- Write robust C# code to manipulate items, fields, and their versions within the Sitecore context.
- Develop efficient item retrieval strategies using Database.GetItem and understanding the Sitecore cache.
- Automate content tree modifications, such as creating folder structures and content items via code.
- Ensure data consistency during item updates by correctly using the item.Editing context.
💡 Top Tips to Prepare
- Memorize the key methods on the Item object, such as Add, Delete, and properties like Fields and Versions.
- Practice writing code that creates an item from a specific template, updates its field values, and then deletes it.
- Understand the performance and reliability benefits of using ID over path for item lookups.
- Review the API for accessing and managing language versions and numbered versions of an item.
📖 About this Domain
This domain covers the foundational architecture of the Sitecore Experience Platform (XP). It details the core components, the content tree, and the roles of the primary databases. Mastery of this area is essential for building solutions on Sitecore.
🎓 What You Will Learn
- Learn the distinction between Content Management (CM) and Content Delivery (CD) server roles in a scaled environment.
- Understand the specific functions of the core, master, and web databases in the Sitecore ecosystem.
- Grasp how Sitecore structures all data as items within a hierarchical content tree, based on data templates.
- Explore item serialization using tools like Sitecore Content Serialization (SCS) for DevOps integration.
🛠️ Skills You Will Build
- Ability to navigate the Sitecore backend, including the Content Editor and Desktop interfaces, to locate and manage items.
- Skill to identify the correct database for troubleshooting content, security, and application data issues.
- Competency in relating a Sitecore item to its underlying data template to understand its fields and structure.
- Proficiency in explaining the flow of content from the master database to the web database via the publishing process.
💡 Top Tips to Prepare
- Log in to a clean Sitecore instance and thoroughly explore the default item structure under the /sitecore node.
- Review the showconfig.aspx page to understand how configuration files are layered and how database connections are defined.
- Perform several publish operations, including item, smart, and republish, to observe their effects on the web database.
- Use the Sitecore CLI to pull and push items, familiarizing yourself with the .yml file format and serialization commands.
📖 About this Domain
This domain covers the hierarchical structure of all Sitecore items, known as the Content Tree. It is the primary interface for content authors and a foundational concept for developers, defining the information architecture of the solution. Understanding the tree's organization is critical for item manipulation and content modeling.
🎓 What You Will Learn
- Learn the fundamental concept of a Sitecore item, its unique ID, and its relationship to a data template.
- Understand the key root nodes of the Content Tree, such as /sitecore/content, /sitecore/layout, and /sitecore/system.
- Grasp how Sitecore manages item versioning, including numbered versions and language-specific versions for multilingual sites.
- Discover the role of __Standard Values in providing default field values and the use of tokens like $name for dynamic content.
🛠️ Skills You Will Build
- Ability to create a logical information architecture by structuring items within the Content Tree.
- Proficiency in using the Sitecore API to programmatically retrieve and manipulate items and their fields.
- Skill in configuring __Standard Values to enforce content governance and streamline content creation.
- Competency in managing multilingual content through the creation and maintenance of item language versions.
💡 Top Tips to Prepare
- Memorize the location and purpose of the primary nodes within the /sitecore root, especially content, media library, layout, and templates.
- Practice creating items based on templates with and without __Standard Values to observe the difference in initial field population.
- Use the Sitecore API to fetch an item by its path and its GUID to understand the two primary methods of item retrieval.
- Create a single item, add several numbered versions, then add a new language to that item to see how the versioning system works.
📖 About this Domain
This domain covers Sitecore's multilingual features for managing and delivering localized content. It focuses on the configuration of content languages, item versioning strategies, and mechanisms like language fallback. You will explore how Sitecore handles language-specific data within the content tree.
🎓 What You Will Learn
- You will learn to add and configure new content languages within the Sitecore instance.
- You will understand how versioned, unversioned, and shared fields behave across different language versions of an item.
- You will discover how to configure and enable language fallback at the item and field level to manage untranslated content.
- You will learn to use the Sitecore Dictionary to manage and render localized, static text labels in your renderings.
🛠️ Skills You Will Build
- Ability to architect a multilingual Sitecore solution by correctly configuring languages and site definitions.
- Skill to implement a content strategy using versioned and unversioned fields for an optimal translation workflow.
- Competency in setting up language fallback chains to reduce content duplication and translation effort.
- Proficiency in localizing component UI text using the Sitecore Dictionary API and patch files.
💡 Top Tips to Prepare
- Experiment with creating language versions of an item and observe how shared versus versioned field values are inherited or differ.
- Configure the enforceVersionPresence and languageFallback attributes on your site definition to understand their impact on item resolution.
- Practice retrieving Dictionary entries programmatically using Sitecore.Globalization.Translate.Text() in a view rendering.
- Review the Sitecore.LanguageFallback.config file to understand the default provider and pipeline configurations.
Premium Access Includes
- ✓ Quiz Simulator
- ✓ Exam Mode
- ✓ Progress Tracking
- ✓ Question Saving
- ✓ Flash Cards
- ✓ Drag & Drops
- ✓ 3 Months Access
- ✓ PDF Downloads