From building your Shopify store
to running it — leave it all to us.
New builds, rebuilds, added features, custom apps, external integrations, and improvement after launch.
We come in while the requirements are still unsettled, work out what should be built, and deliver it as something that runs.
WHERE TO START
Start the conversation from any stage
A project you're about to start, or a store already running — either is fine.
Come to us from wherever you are now.
Starting something new, improving what runs, or taking something over.
If nothing is decided yet, we start by hearing what you want to achieve. If things are already moving, we review what exists and take over only the steps you need. We also take ongoing engagements for post-launch improvements and maintenance alone.
- The products are decided, but the structure and features are not
- We want you in from requirements definition onward
- We need someone to take over a Shopify store another company built
- We want improvement and maintenance handled on an ongoing basis after launch
Shopify engineering, for your projects.
On projects where you own the client relationship, we join with a scope limited to requirements, implementation, and technical research. The client stays yours. The details of how we work together are on a dedicated page.
- You have a large Shopify project but not enough specialist resources
- You need client wishes translated into an implementable spec
- You want to think through feasibility together, from the pitch stage
WHAT WE BUILD
The four areas we are asked about most
We confirm how far Shopify itself will take you, then design and build only the parts that need it.
Shopify store builds and rebuilds
New builds, reviews of a running store, or implementation from supplied designs — all of them.
From the purchase path — collection pages, product pages, cart — through to headers and shared sections, we design and build it as a single theme.
We check how it will be run after launch first, so the parts that change often can be edited from the admin and the parts used repeatedly are shared.
We build themes that don't need a developer for every small change.
Public app selection, setup and surrounding customization
From “can an app solve this requirement?” through to fitting it to how you actually work.
Installing a public app on its own can leave gaps — fit with the theme, interference with other apps, things settings alone won't reach.
Where needed we combine theme work and Shopify's own features to finish the screens and the operations people actually use.
Before installing, we check not only the features but the cost, the constraints, and how easy it will be to change later.
Custom app development and system integration
Requirements that standard features and public apps can't reach, implemented as custom apps or API integrations.
We build the machinery that moves data correctly between the places it lives — inventory, orders, customers, B2B, core business systems.
Before implementation we settle which data is authoritative, when it syncs, and what happens when a sync fails.
Even where the other side has no written specification, we can start by establishing one from how it actually behaves.
Migration from other platforms, and store takeovers
Move a running store without taking it down. Take one over with no one left to ask. Both start with understanding the current state.
For a migration, we map the source data against Shopify's fields and sort out what's missing before moving anything.
For a takeover, we read how the theme, apps, settings and integrations fit together to make it work.
We don't stop at moving it — we hand it over checked to the point where you can keep running and improving it.
DATA & OPERATIONS
Data design that supports operations
As operations pile up, data with the same meaning multiplies in different places, until no one knows which is correct. That's why we design not just the screens, but the data your operations run on. This too is a deliverable you can commission on its own.
Data structure for products and content
What starts the drift is almost always an urgent campaign. Add a field every time you're in a hurry and similar information ends up on the product, in the theme and in an app; six months later nobody knows which one to update. We design how metafields and metaobjects are held, align their names and roles, and structure them so the same content isn't duplicated. When someone new takes over, they can read the name and purpose and update it.
Integration specifications
Start without deciding which side is authoritative and both Shopify and the external system become authoritative. Both numbers look plausible, so every discrepancy turns into work. We settle which data is the source of truth, which fields are exchanged, when syncing happens and what is retained on error, and deliver it as an integration specification everyone can build and test against.
What can be changed from the admin
So that you don't have to commission development every time a line of copy changes, we expose the wording and settings that shift often in the theme editor. But exposing everything makes it harder to find what you're looking for. We narrow it to what actually gets touched, and hand it over with each control tied to the screen it changes.
WAYS TO WORK
Two ways to work with us
When what you want built is already decided, project-based development.
When you want judgment and improvement to continue, the monthly tech support plan.
Depending on the work, one-off engagements and ongoing support can be combined.
We agree the deliverables and scope, and see it through to completion.
New builds, rebuilds, substantial feature additions, custom apps, external integrations.
We itemize what is built and what is delivered, quote against that, and implement and review to the agreed specification.
If a new request comes up mid-project, we discuss each time whether to include it now or hold it for later.
Contract type: fixed-scope (ukeoi) agreement
A monthly allowance for ongoing advice and improvement.
Requirements work, technical investigation, small fixes and modest feature additions, all within a monthly allowance of time.
It isn't only bug fixes — a lot of what comes to us is thinking through whether something is worth starting now.
- Can this campaign be done on Shopify?
- Which app should we choose?
- Which initiative should come first?
- Can these rough requirements be shaped into something we can propose?
- Are this estimate and these requirements reasonable?
As the conversations and the work accumulate, we come to know the store's history too — so you don't have to explain it from scratch each time.
Contract type: retainer (jun-inin) agreement
OUR SCOPE
What we cover, from first conversation to handover
From settling requirements and drawing the screens to implementing and handing over something you can run.
We take on projects where we handle the design, and projects where we implement designs you supply.
We sort the requirements and settle on the approach.
We start from before it's fully put into words, and separate the goal from the request.
We draw the lines between what Shopify covers, what existing features handle, and what needs development
Screen design and visual design, where needed.
From wireframes through to implementation-ready design.
When you supply the design, we check that it can be built and that it holds up as products and images increase, and propose the adjustments needed.
From the theme to custom apps and external integrations.
Theme code, Liquid, Shopify Functions, app configuration, custom apps, API integrations — we combine whatever the agreed specification needs.
We verify against real product and order data, checking the processing as well as the display.
We launch it and hand it over ready to run.
We launch once data migration, configuration and testing are done.
After launch we walk you through the screens and settings you'll touch day to day, and hand over to the point where you can run it yourselves.
PROCESS
From first conversation to launch
A store build typically takes two to three months, a small custom app about two weeks, and an external integration about a month once the documentation is in hand.
The schedule accounts for more than the development itself — supplying assets, your reviews, and internal sign-off are all part of it.
First conversation
You don't need to have decided how it will be done. Tell us what you want to build, what's giving you trouble, and the conditions you already know.
If you have the current store or any materials, sharing them at this point makes it smoother.
Framing the goal and the requirements
Rather than turning your request straight into a specification, we go back to what you're trying to achieve.
Walking through how it will be run, we establish the features needed and what still has to be decided.
Proposing the approach and the scope
We propose how to meet the goal.
Where there is more than one way, we lay out the differences in cost, constraints and day-to-day operation.
How far to go this time is decided against your budget and priorities.
Estimate and schedule
We itemize the work and the deliverables, and issue an estimate and a schedule.
If the budget falls short, we don't lower quality — we separate what is done now from what moves to a later stage.
Implementation and verification
We build in a development environment and verify using real product and order data.
Alongside the display, we test the processing and the data flows that matter.
Launch
We apply the reviewed work to production and check how it behaves once live.
Where a running store is being switched over or external systems are involved, we follow a procedure agreed in advance.
Walkthrough and handover
We walk you through the admin screens and operations that relate to what was built.
Code, accounts, specifications — we put together what you need and hand over ready for you to run it yourselves.
Post-launch changes and ongoing technical advice can also be covered by the monthly tech support plan.