--- title: Store Review Process and Quality Expectations | Shopware Community Hub description: >- Understand the Shopware Store Review process, quality expectations, automated checks, manual review, and submission readiness. canonical_url: >- https://hub.shopware.comhttps://hub.shopware.com/learn/unit/store-review-process-and-quality-expectations --- # Store Review Process and Quality Expectations - Plan the Store Review process in a structured way. - Understand automatic and manual checks as quality support. - Organize your own testing before submission. - Consider the requirements for successful Store approval early in the process. # Store Review Process and Quality Expectations Publishing an extension in the Shopware Store is not only a technical upload. The extension must also pass a review process that checks whether it is reliable, secure, understandable, and suitable for merchants. The Store Review should not be treated as a replacement for your own testing. Shopware describes it as a supplement to the partner's own automated and manual tests. That means partners should prepare their extension before submission, not wait for the review to find basic issues. In this unit, you will learn what the Store Review process is for, which types of checks are involved, and how to think about review readiness before you submit an extension. ## Store Review Complements Your Own Testing The Shopware Store review and quality documentation explains that Store Review is for extension developers who want to distribute plugins, apps, or themes through the Shopware Store. The review checks whether an extension: - Stays within supported integration boundaries - Behaves predictably for merchants and customers - Meets listing, security, and compliance rules - Follows expectations for Storefront behavior, SEO, privacy, lifecycle, and code quality The important mental model is this: > Store Review is not the first quality check. It is a final external review after you have already tested the extension yourself. For partners, this changes how the submission process should be planned. The goal is not to upload quickly and wait for feedback. The goal is to submit an extension that already matches the expected quality level as closely as possible. ## What Shopware Checks During Review The Quality Guidelines for Store Extensions describe review expectations for extensions distributed through the Shopware Store. The review process includes both automatic and manual checks: - Automatic code review, including tools such as PHPStan and SonarQube - Manual review for security, coding standards, user experience, and functionality - Testing on the latest stable Shopware 6 Community Edition version - Additional app-related checks, such as `config.xml`, install and uninstall behavior, and styling or viewport issues These checks are not only technical gatekeeping. They help protect merchants from extensions that are fragile, unclear, unsafe, or difficult to maintain. For partners, this means that Store Review expectations should influence development early. Code quality, storefront behavior, configuration, listing content, uninstall behavior, and compatibility should not be added only at the end. ## Review Readiness Starts Before Submission A structured review process begins before the extension is uploaded. Before submission, partners should be able to answer questions such as: - Have we tested the extension against the highest supported Shopware version? - Does the extension stay within supported APIs and extension points? - Does it avoid unsupported access to core files, internals, or unsafe database behavior? - Does it behave correctly in the storefront, administration, checkout, and relevant sales channels? - Are install, update, deactivate, and uninstall scenarios tested? - Are Store listing texts, translations, images, and feature claims accurate? - Are external services, cookies, privacy behavior, or additional costs disclosed where needed? This does not mean that every extension needs a large enterprise test process. It means every partner should have a clear submission checklist. ## Automatic Checks Are Feedback, Not a Surprise Extensions move through several statuses during their lifecycle, including `Code review required`, `Code review failed`, `Pending approval`, `Approved`, and `In store`. These statuses help partners understand where an extension is in its lifecycle: | Status | What It Means for the Partner | |----------------------|-----------------------------------------------------------------------------------| | Incomplete | Required extension details are still missing. | | Code review required | A code review has not yet been requested for at least one version. | | Code review failed | The automated code review found issues that need to be fixed. | | Pending approval | The automated code review passed and the extension is waiting for manual testing. | | Approved | The extension has been reviewed and can be enabled for the Store. | | In store | The extension is approved and available in the Shopware Store. | The important point is that these statuses are part of the product workflow. They are not just administrative labels. If the code review fails, partners should treat the feedback as part of their quality loop. Fix the issue, upload a corrected version, and use the result to improve internal checks before the next submission. ## Manual Review Looks at the Product Experience Automatic checks can find many technical issues, but they cannot fully judge the merchant and customer experience. That is why manual review is also part of the process. Manual review can include topics such as: - Security and coding standards - User experience in the storefront or administration - Functional behavior - Setup and configuration clarity - Store listing quality - Compliance and privacy expectations - Install and uninstall behavior This is why partners should not only ask, "Does the code run?" They should also ask, "Can a merchant understand, configure, use, and trust this extension?" That question connects Store Review to the previous units. Your partner profile, support process, technical extension type, and product maintenance plan all shape whether the extension feels reliable. ## Example: Preparing a Submission Imagine a partner preparing a first extension for submission. The main feature works locally, and the extension can be installed in a development shop. At this point, the partner should not immediately upload the extension and wait for review feedback. A better first pass would be: - Test the extension on the latest supported Shopware version. - Check whether the extension uses supported APIs and extension points. - Run static analysis and fix obvious warnings. - Test install, update, deactivate, and uninstall behavior. - Verify storefront and administration behavior without console errors or broken pages. - Review Store listing text, screenshots, translations, and feature claims. - Check whether external services, costs, cookies, or privacy-relevant behavior are disclosed. This preparation makes the Store Review more predictable. It also helps partners build a repeatable release process for future versions. ## Common Pitfalls ### Treating Review as the First Test Store Review should not be the first time the extension is tested seriously. Partners should run their own checks before submission. ### Focusing Only on Code Code quality matters, but Store approval also depends on listing quality, user experience, security, compliance, lifecycle behavior, and clear configuration. ### Ignoring Status Feedback Statuses such as `Code review failed` or `Pending approval` tell partners where the extension is in the review workflow. They should be used to plan next steps. ### Testing Only the Happy Path Install, update, uninstall, invalid configuration, external service failures, storefront behavior, and administration behavior can all affect review readiness. ## Summary - Store Review complements the partner's own automated and manual tests. - Shopware checks supported integration boundaries, predictable behavior, listing quality, security, compliance, and code quality. - Automatic checks such as PHPStan and SonarQube help identify technical issues before manual approval. - Manual review also looks at user experience, functionality, security, and merchant-facing behavior. - Partners should treat review readiness as part of the development process, not as a final upload step. Next, you will move from the foundations of the Extension Partner role into technical quality and integration readiness for Store-ready extensions.