• Enhancements

Modifying someone else's store: we take on the code that others wrote

Modifying someone else's online store means working with code that we did not write and for which there is usually no documentation. We take on such stores on OpenCart and WooCommerce, but with one condition: code audit first, then the amount and term. The reason is simple. In someone else's project, time is not consumed by the change itself, but by finding out what it will affect: how many platform files are edited directly, whether it is possible to upload a copy for tests, which will break in the checkout from one new button.
See how it works
Price
after a free audit
Guarantee
30 days after project sign-off
Where do we start?
code audit 3-5 business days, before any edits
after a free audit
Price
30
Guarantee

days after project sign-off

code audit 3-5 business days, before any edits
Where do we start?
5-40
The term of the finalization itself

working days, depends on the status of the code

a copy of the store on the test site, not a combat site
Where edits are made
OpenCart 3.x and 4.x, WooCommerce
Platforms
in both stores measured here, the sitemap returned an HTTP 200 with an empty body
What we see in other people's stores
payment by stages, guarantee of 30 calendar days for completed works
Conditions

Free audit of someone else's store before completion

Before naming the price, we look at what we will have to work with. This is not a "quick look": a few days of working with the code and the base, after which it is clear what can be done safely and what needs to be fixed first.

What we measure

  • Edits in the core of the platformHow many platform files are modified directly instead of mods. We find by comparison with a clean assembly of the same version. Each such edit is something that will disappear with the update, and something that will have to be taken into account in each subsequent task.
  • Platform and environment versionsWhat everything works on. PHP 7.3.33, the unsupported version as of December 2021, is regularly encountered in the stores we measured on OpenCart 3.x. This affects both security and what modules will become in general.
  • Technical condition, which is visible from the outsideSite map, markup, response speed. For a 3,565-item heating equipment store, the sitemap and platform feed were returning HTTP 200 with an empty body, /sitemap_index.xml was returning 404, and there were no JSON-LD blocks on the master.
  • Analytics and countersIs there anything at all to measure the result of finishing. The 5,561-bay cosmetics store didn't have a single counter — no tag manager, no analytics, no pixel; any change there would be scored blindly.
  • Ability to expand a copyAre there accesses, a base dump and a place for a test site. Without a copy, edits go immediately to the combat site — this is the main risk in working with someone else's code.
  • The real complexity of your taskWhat specifically will have to be touched to do what you ask, and what places can break in doing so. It is from here that the difference in times between verbally identical tasks comes from.

What you get

  • Status document: versions, core edits, technical defects, analytics status.
  • The evaluation of your task in two lines: how much is the modification itself, how much is bringing the code to a state in which it can be done.
  • List of risks: what can break and what we will do to prevent it from happening.
  • Conversation for 30–40 minutes on the document, without presentation.

Timeline: 3-5 working days

Why is it free

Because you can only name the price of the modification without looking at the code at random, and then this figure either increases in the middle of the work, or has a built-in reserve for which you pay. The document remains with you regardless of whether we continue to work or not.

What's next

After the audit — the amount and term by stages with dates, contract, invoice, report. If it becomes clear from the code that it is cheaper to redo than to finish, we will say it directly and show both figures.

Short form: your contact and site URL

  • Contract, act and 30-day warranty

    Every project gets a written contract: scope, deadlines, amount, acceptance procedure. After delivery — act and invoice, then 30 calendar days of warranty.

  • Sole proprietor & bank transfer

    The contractor is a registered sole proprietor. Payment by invoice with closing documents.

  • Rights & access — yours

    Code, design and materials transfer to you after full payment. Domain, hosting, repository and analytics are registered to you.

  • Client portal instead of email chains

    During the project you get access to a portal: contracts, invoices, acts and project status in one place.

  • European clients

    Among our work — projects for Norway, Bulgaria, Moldova and Spain.

  • Verifiable numbers

    Every case in the portfolio comes with a link to a live site and a technical measurement.

  • Audit first, then pricing

    There is no price list on the site intentionally: the scope of the same work differs multiples between clients.

  • We say "no" when unsure

    If the task isn't ours or the deadline is unrealistic — we tell you upfront.

What affects the price

Why two seemingly identical tasks are priced differently

  • The number of edits in the core of the platformPrime factor. The store, where the extensions are made by modifiers, is finished predictably. The store, where the platform files were ruled directly, requires checking these places in every task — and time is spent not on the code, but on finding out the consequences.
  • Can I pick up a copyThere are accesses, a base dump and a place for a test site — work is proceeding at a normal pace. There is none of this - everything slows down: you have to rule carefully, in small steps, with a check after each one.
  • Platform and PHP versionOn a branch without support, some of the necessary libraries and modules are simply not installed. Then the rework starts with the environment update, and it's a separate estimate line that we show before the start, not in the middle of the work.
  • How close the task is to moneyA change in the product description and a change in the checkout are different things in terms of risk. Everything that touches the cart, payment or shipping requires an end-to-end run of the order to checkout, and that run is paid for in time.
  • Analytics statusIf there are no counters on the site, you can make improvements, but it will be useless to compare "before" and "after". It is your decision to put analytics separately or to accept that the result is evaluated based on sales and the words of managers, and it also drives the estimate.
  • Number of people on your sideOne person with the right to accept jobs - coordination in hours. Three with different opinions - in weeks, and in someone else's code, this delay is more expensive: the context has to be brought up every time anew.
Who it's for

Situations where this service delivers results

Scenario 1 of 4

The developer is gone, and the store is working and making money

The most common scenario. The site is alive, orders are coming, but nothing can be changed in it: the person who wrote it does not respond, there are no sources or explanations. We enter from the entrances, pick up a copy and first describe what is inside. Next, you make a decision based on the document, and not on the feeling that "everything is bad there."

We'll review your situation in a free audit
What's included

Complete list of work and what you get as a result

  • We deploy a copy of the store on the test site - all edits are there first, the combat site continues to sell
  • We introduce the code into the version control system, even if it was not there before us - a history of changes and a "return to the way it was" button appears
  • Compare the files with a clean build of the platform - you get a list of places where the previous contractor managed the kernel
  • We write a description of the found state: versions, modules, edits, places that are better not to be touched - this document remains for you
  • We implement the task itself taking into account the existing architecture, and not contrary to it — so that the next revision does not begin with the analysis of our
  • We make changes with standard extension mechanisms where possible - such a change survives the platform update
  • We drive away related scenarios after the change: shopping cart, checkout, payment, delivery, admin — that’s where the consequences come out
  • We publish on the combat site with the possibility of rolling back and fixing the time of work - so that you can see when and what has changed
  • We give a short instruction for your manager on what has changed in the admin
  • We give a separate list of the problems we found that we did not touch, with an estimate - it is up to you to decide what to do with them
When this service isn't right

What's not included — so there are no surprises at delivery

  • Liability for defects that existed in the code before us and that we did not touch
  • A complete rewrite of the store under the guise of finishing touches is a separate job with a separate estimate
  • Restoring missing sources
  • Licenses for paid modules installed by the previous contractor
  • Hosting, domain, acquiring
Process steps

Transparent stages with approval at every step

Total duration:5–40 days

  1. Code and database audit

    3-5 working days

    We look at versions, compare files with a clean build of the platform, count edits in the core, check the sitemap, markup and counters. The output is a status document and a two-line assessment of the task. This stage is free.

  2. Copy, version control and problem formulation

    1-3 working days

    We set up shop on the test site, get the code into Git, rewrite your task from human language to technical language, and agree on exactly what is considered done. Without this acceptance turns into an argument.

  3. Implementation on a copy

    2-25 working days

    The finishing touch itself. By staff extension mechanisms where possible; if a task requires a kernel edit, we record this in a separate line and explain what will happen in the next update.

  4. Check related scripts

    1-8 working days

    Running the order from the cart to checkout, checking the payment in the test mode of the provider, delivery, admin and manager roles. Here it is caught that the change affected, although not small.

  5. Deployment to the combat site and observation

    1-4 working days

    Presentation with the possibility of rollback, during working hours, when there is someone to watch. Next, we keep our finger on the pulse for a few days: errors on the combat site appear on real orders, not on test ones.

Did not find your case?

Describe how it works on your side — we will tell you whether “Modification of the online store, which was not made by us” fits and what it means in your situation. No brief and no call: one question, one answer.

Cases

Tasks and results in numbers — all metrics measured by us

retail store of heating equipment, catalog of about 3.5 thousand items

Task
Assess the condition of the existing store before finishing: how many items are actually in the catalog, what with the technical part and what works are needed first.
Solution
Measurement by regular means: counting the catalog by searching the platform with an empty request, checking the site map and feed, measuring the response time and the weight of the markup, checking structured data and counters.
Result
3,565 product cards — 35 pages for 100 items and 65 for the last one. First server response 524.8ms, full load 662.7ms at 295.7KB HTML. There are four payment methods in the checkout, including monobank and non-cash account for FOP and LLC with VAT, four delivery methods, two language versions with correct language markings. Found: sitemap and platform feed return HTTP 200 with empty body, /sitemap_index.xml - 404, no JSON-LD block on parent. A separate discovery: in the description of the project, the stack was listed as Next.js, in fact OpenCart 3 and PHP are there. All this is the state at the time of measurement on 07/31/2026, and not the result of our work.

online store of professional cosmetics, catalog of over 5,000 items

Task
Understanding why a store with a large catalog does not give a clear picture of sales and what to do is the first step.
Solution
The same measure: a catalog with a regular platform search, a site map, counters on the main page, a delivery page, structured markup.
Result
5,561 products in the live catalog — 55 pages of 100 items and 61 for the last one. Main HTML 153.8 KB, first server response 801.2 ms. Found: sitemap and feed return HTTP 200 with empty body; there is no counter on the main one - no tag manager, no analytics, no pixel; no carrier is listed on the shipping page. There is markup, but only Organization and PostalAddress. The store worked and sold, and the result of any improvement in it was impossible to measure. Measured on 07/31/2026.
Technologies & integrations

What we build on and what it connects to

Stack

  • OpenCart 3.x and 4.x - this is where most of the stores that bring finishing touches; in 4.x, the event system was rewritten, and there are no Ukrainian modules for it
  • WooCommerce — when the store lives on WordPress; third-party plugins update themselves and can break the plugin
  • PHP and MySQL are the language and database of the existing store, there is no choice; on the version without support, some libraries will not work
  • Git — code under version control for rollback; we cannot restore the history of changes
  • The test site as a copy of the combat one — edits there first; there is no copy of the payment gateway, payment is measured by the provider's test mode
  • Platform mods instead of kernel edits — the change survives the update; they cannot do some of the tasks, and we say so directly
  • Comparison with a clean assembly - it is clear that the predecessor ruled; Substitutions due to the topic are not caught that way

Integrations

  • payment providers already connected on the site
  • carriers already connected on the site
  • 1C / BAS
  • Google Tag Manager and GA4
  • Search Console
  • Telegram, Viber
Modify an existing store or create a new one

How this option differs from the alternative

When the desired function appears5-40 working days for the task, the store sells all this time
Addresses and indexaddresses do not change, no redirect map is needed
Inherited defectsremain until you decide to take them to work; we name them, but we do not touch them in silence
Estimate predictabilitylower: in someone else's code, part of the work is revealed in progress, which is why an audit to the number is needed
What we need from you

We can't start without this — best to prepare in advance

  1. Access: admin, FTP or SSH, database, hosting panel. Without access to the code and database, the conversation ends here.
  2. Description of the task in our own words - we will rewrite it in technical language.
  3. Permission to deploy a copy of the store on the test site.
  4. The contact of the previous contractor, if the contact is saved; if not, it's not an obstacle, it's just that the audit will take all five days instead of three.
  5. One person with the right to make decisions and accept jobs.
  6. Time for acceptance: the modification is checked by the one who will use it, and preferably before it is posted on the combat site.

If something is missing — let us know, we'll help you gather it or do it as a separate task.

FAQ

Most frequently asked questions — with concrete answers

Are you taking on someone else's code?

Yes, this is a separate line of work. One condition: first the audit. We don't quote a build price without seeing how many core edits are in the store, whether a copy can be lifted, and what will break from the change you're asking for. The audit is free, takes 3-5 working days, the status document remains with you in any case.

Why can't you name the price right away, I have described the task?

Because the price is not determined by the task, but by the code under it. In someone else's project, the lion's share of time is spent not on the change itself, but on finding out what it will affect. If the previous contractor edited the platform files directly, each new feature requires checking these locations. That's why we count completion in two lines: the task itself and bringing the code to a state where it can be done safely. The second row is larger than the first - and it is better to see it before the start.

And if the code is completely bad - to finish or rewrite?

We will show both numbers: how much it costs to modify this code and how much to redo it. Sometimes it's cheaper to rewrite, and it's fairer to say so before the start, rather than after half the budget has gone into fighting the old code. The decision is up to you, and we take on both options.

Will the combat site not be damaged during the works?

Edits go to the copy. First, the store is raised on the test site, all changes are made and checked there, and only then they go to the combat site with the possibility of rollback. We teach during working hours, when there is someone to watch. Editing production directly is the shortest way to a store that is closed on Friday evenings.

Will you find problems I didn't ask for?

Almost certainly. We will describe them in a separate list, but we will not silently correct and invoice. The 5,561-bay cosmetics store didn't have a single counter — no tag manager, no analytics, no pixel. This is serious, because without counters, the result of any modification has nothing to compare with. But it's not our job until you decide it's yours.

I have an old version of PHP - is that interfering?

Often yes. PHP 7.3.33, a version that has not been supported since December 2021, is a regular occurrence in the stores we measured on OpenCart 3.x. Some modern modules are not installed on it, and some work unpredictably. Sometimes the finishing touches have to start with updating the environment, and it is more honest to see it in the audit than in the middle of the work. The update is done on a copy, with a checkout check before switching.

How long does the finishing work take?

From 5 to 40 working days depending on the task and the status of the code, and this is after the audit. Small change at a tidy shop - a few days. A new feature on a site with dozens of core edits is the upper limit, and most of the time there is spent not writing code, but checking that nothing is broken in the cart, checkout, and shipping.

Access is incomplete: there is an admin, but no one gives access to the hosting and database. Is that possible?

Partly and with limitations that should be understood. You can see the modules and settings through the admin itself, but you can't see what was changed in the platform files, and you can't pick up a copy of the store without a database dump. That is, we will be able to estimate the task approximately and work more carefully and longer. Our recommendation: access to the hosting and database should be yours, not just the contractor's — it's the basic hygiene of website ownership, and it's worth asking for them before something breaks.

Describe what needs to be done and give access — we'll look at the code and tell you what we're dealing with.

In response: a document on the state of the store, a two-line assessment of the problem and a list of risks. If it is unprofitable to complete, you will hear it in the first email.

From measured cases3,565 product cards

View cases
  • Reply within 2 hours
  • No commitment
  • We work under a contract

There is no price list on the site on purpose: the same work differs several times over between two clients, and a “from” figure explains nothing in that case. First a free audit — we count your pages, duplicates and speed — then we name the sum and the deadline and fix both in the contract.