Our journey to a successful implementation
When our team at Arnia Software was approached to deliver a Shopware-based ecommerce solution for a client, there was one glaring challenge: none of us had ever worked with Shopware before.
This is the story of how we went from absolute beginners to delivering a fully customized Shopware project in just seven months. It’s about uncertainty, learning curves, teamwork, discipline, and the power of developer curiosity.
The challenge: New territory
Early in 2024. We received a project that, at first glance, felt familiar: replacing a legacy, hard-to-maintain ecommerce system, but this time, the tool was unfamiliar. Shopware was chosen by the client due to its flexibility, total cost of ownership, and promise of no-code configurability for operational staff.
Our background was solid in eCommerce; Magento and Symfony formed the core of our technical stack. But Shopware? That was entirely new territory. We quickly realized that ramping up wouldn’t be as straightforward as following a guided course. The official documentation was fragmented, and community learning resources were limited at the time. We dug through the available documentation, watched a bunch of videos, and rolled up our sleeves to explore the actual code. There wasn’t a step-by-step guide, so we had to learn by doing it. Alongside the technical digging, we made sure to talk things through, clarifying business needs with the client and openly sharing what we were learning with each other. This mix of hands-on practice and open communication helped us move from being unsure of where to start to building real confidence in what we were doing.
Getting started: The learning curve
We had to get up to speed quickly and in a smart way. Learning Shopware meant more than just getting familiar with the platform and its APIs. We also had to find clear and effective ways to share knowledge and communicate. Clear communication, both within our team and with the client, was just as important as the technical side of things. We tackled the technology head-on with three primary learning resources: Shopware Academy, YouTube tutorials, and the codebase itself.
Shopware Academy – initial video training
YouTube tutorials – contains a bunch of targeted video tutorials for specific functionalities
Shopware Developer Documentation v6.6 – we were on version v6.6 at the time, v6.7 hadn’t been released yet.
Dockware for local development environment
We kept learning focused and practical. For example, when someone had to implement an event webhook for the first time, they worked on just that, without distractions. We gave each task a time limit so we wouldn’t get stuck too long before getting feedback.
Then the outcome was shared within the team. Moving fast and learning on the go worked best when we could check progress early.
Good planning made a big difference. We broke work into clear, simple tasks and matched them to whoever had the most hands-on experience. We also made sure we knew exactly who at the client's side could give us quick, clear answers when we needed them.
To avoid going over the same things repeatedly, we put together simple steps for routine tasks, like how to deal with plugins or extensions. We made sure that each one went through a quick checklist before being added to the codebase, so everyone knew what to expect and we could keep things moving smoothly. Everyone knew what to expect and it helped us move faster. We were open with the client from the start about the learning curve and made sure our timelines reflected that. This honest approach helped build trust. We didn’t try to perfect everything upfront, but we did stick to best practices and focused on what mattered most at each stage.
The project itself: Integration meets customization
The client’s web shop was running on older systems that had become harder to maintain and update. It was built on PHP 7.4, and over time, small fixes and workarounds had piled up to keep things running.
Our job was to make sure the new Shopware setup could connect smoothly with all the other tools the client relied on. In many cases, that also meant replacing outdated integration solutions with more modern and stable ones. We worked on connecting ERP systems for inventory and order management, payment providers, and the custom processes they used to handle and organize product data, just to name a few.
We took the features from the old system and gave them a fresh take that fits naturally into how Shopware works. One of the critical challenges was orchestrating the flow of data between Shopware and external systems. To address this, we adopted an event-based approach, using a mix of webhooks and API calls depending on the specific integration scenario. Webhooks were ideal for real-time communication, such as pushing order status updates or notifying external systems about stock changes. API calls, on the other hand, were used when reliability, control, or data aggregation was more important, like pulling product updates in batches or confirming payments.
To ensure consistency and flexibility, we used an iPaaS (Integration Platform as a Service) layer as the middleware between Shopware and the external systems. This platform helped us manage message routing, retries, transformations, and logging in a centralized and scalable way. By defining a clear structure for webhook events, validating payloads, and designing fallback mechanisms in the iPaaS layer, we created a robust and maintainable integration strategy. This middleware approach also allowed us to decouple Shopware from the target systems, making future changes more manageable. This integration architecture became one of the core strengths of our overall delivery.
Getting comfortable with Shopware and building the eCommerce platform was part of it, but just as important was making sure everything played nicely with the other systems we work with.
Internal Management: How we led the team
We were a team used to working with Magento and Symfony, so shifting to something completely new like Shopware naturally raised some eyebrows. It’s normal, any big change can make people uneasy. But from the start, I made it clear: this is the direction we’re heading, these are the tools we’re using, and we’re all in this together. The team got it. There was a shared understanding that even if this wasn’t our comfort zone yet, we’d grow into it together, step by step.
To keep things moving, we looked at who on the team was starting to get more familiar with certain parts of the work and gave them tasks that matched their growing experience. It made everything run smoother and gave people a chance to take ownership and help each other out naturally. Just as important was how we communicated, both with each other and with the client. A big part of the learning curve wasn’t just the tech, but also how we worked together and kept things clear. We made sure everyone knew who to ask, how to share updates, and when to check in. Having that steady back-and-forth helped us make real progress, not just by learning, but by applying what we learned in the right way.
Lessons learned
Throughout the project, we recognized that delivery without preparation is risky, and that learning while building only works if the groundwork is solid. We made a point of keeping the client informed about the inherent learning curve and setting realistic expectations from the start. Defining tasks clearly and aligning them with the areas of growing expertise within the team allowed us to make meaningful progress while continuously learning. We didn’t aim for perfection in every decision, but we made a conscious effort to follow Shopware’s best practices where it mattered most. That balance helped us move fast without cutting corners.
You can’t fake planning. Define what you’ll deliver before you start.
Use the code as your compass. When docs fail, the source speaks.
Respect the learning curve. It’s costly. Bake it in.
Small wins build confidence. Celebrate the first theme build, the first plugin, and the first successful deployment.
Looking Ahead Today, Shopware is a fully integrated part of our development workflow. We’re not experts yet, we’re still learning every day and steadily improving our understanding. While we no longer feel lost in the platform, we continue to refine our internal practices and sharpen our implementation approach. We’ve built starter kits, boilerplates and reusable patterns to help accelerate projects, and we treat each new task as a learning opportunity. We strive to follow best practices in everything we do, not as a checkbox exercise, but because they lead to maintainable, future-proof solutions.
We also contribute back: suggestions in the community, bug reports, even minor PRs. The ecosystem helped us and now we’re paying it forward.
Closing thought
If you’re tasked with delivering a Shopware implementation from scratch, know this: it’s hard, but absolutely doable. Planning is critical! Define your scope and break it into clear, actionable tasks. Make sure the learning curve is transparent to the client and that sufficient time is allocated for the team to ramp up. Don’t overthink every detail but do respect and follow established best practices. With the right structure, the right team dynamics and an openness to learn, you can go from zero to Shopware hero. Resources for starting with Shopware If you want to start with Shopware today, there are even more resources available than at the time when we started our journey. Here is a list of what you should take a look at before starting, and of course, while working on your project.
The learning paths in the Shopware Community Hub are currently the best way to start your journey
When setting up Shopware for development, look at the different available setups and choose the one that fits your needs
developer.shopware.com in general is a good way to get deeper into the documentation and inner workings of Shopware
The Shopware Community Discord server is a great way to connect with other people and to share and gain knowledge.
Video interview
Want to hear the full story first-hand? In this video, Niklas Dzösch (Shopware) talks with me (Radu Barbu) about challenges, integrations, and key takeaways from their very first Shopware implementation.
