AURORA EVOLUTION – Magento 2 store development on a fixed price
Develop Magento 2 predictably, task by task. You learn the price before the start and we don't move it, while estimation errors are on us.
- The price of a task is known before work begins.
- The accepted amount covers the described scope.
- Any extension of scope requires separate approval.
Magento 2 development — fixed price against hourly billing
Even a sound estimate remains a forecast. With complex code, dependencies between modules and integrations, the number of hours can grow during delivery, and the final invoice grows with it.
This makes the backlog hard to plan. Tasks that matter for sales get postponed, because before work begins there is no way to tell whether their effect will justify the final cost.
With AURORA EVOLUTION you know the price before we start.
First we agree the scope, the assumptions and the acceptance criteria. Then we present a price you can accept or decline. Once accepted, the price does not change unless the scope of the task changes.
| Area | Hourly billingYou pay for time spent | Our modelAURORA EVOLUTIONYou pay for an agreed result |
|---|---|---|
| Information before the start | An expected number of hours or a range | A specific price for the accepted scope |
| Risk of cost increase | The final amount depends on time spent | The estimation risk for the accepted scope stays with the provider |
| Extending a task | Extra work increases the number of hours | New scope receives a separate quote before delivery |
| Basis for billing | Logged working time | The agreed scope and result |
| Backlog planning | Priorities based on an approximate cost | Priorities based on accepted prices |
Information before the start
Hourly billing
An expected number of hours or a range
AURORA EVOLUTION
A specific price for the accepted scope
Risk of cost increase
Hourly billing
The final amount depends on time spent
AURORA EVOLUTION
The estimation risk for the accepted scope stays with the provider
Extending a task
Hourly billing
Extra work increases the number of hours
AURORA EVOLUTION
New scope receives a separate quote before delivery
Basis for billing
Hourly billing
Logged working time
AURORA EVOLUTION
The agreed scope and result
Backlog planning
Hourly billing
Priorities based on an approximate cost
AURORA EVOLUTION
Priorities based on accepted prices
When is fixed-price Magento 2 development the right choice?
AURORA EVOLUTION works when the store is already live and the next features, fixes and improvements can be split into specific tasks.
Task costs regularly exceed the estimate
Before the start you know an approximate budget, but the invoice depends on the hours spent during delivery. It's hard to judge how many tasks will fit into a monthly plan.
The backlog grows faster than it can be delivered
Some changes are postponed because their cost stays unclear. Fixed price makes it easier to weigh a task's price against its value for sales and operations.
You want to test a new partner on a limited scope
You don't have to hand over all development on day one. You can start with a chosen task and assess the quality of the code, the communication and how the work is run.
The board expects a predictable spending plan
Every backlog item can have a specific price before approval. The e‑commerce manager gets the data needed to set priorities and report progress.
Maintenance, failures and monitoring are AURORA CARE
AURORA EVOLUTION covers only planned development tasks with a defined scope and result. Security updates and SLA support are handled in AURORA CARE.
You accept a task against agreed criteria, with no estimate overruns
Fixed price requires better preparation of a task before delivery. The analysis happens earlier, because the scope, assumptions and price are built on it.
- 01
You describe the expected result
You send the task, screenshots and information about the process the change relates to. You don't have to prepare a technical specification.
- 02
We review the code and dependencies
We analyse the current solution, modules, integrations and the areas the planned change may affect. If data is missing, we come back with specific questions.
- 03
You receive the scope and the price
We describe what will be done, the assumptions we make and how we'll recognise the task is complete. That scope has a specific price attached to it.
- 04
We deliver and check the task
After approval, implementation begins. The code goes through technical review and the tests that follow from the task's scope.
- 05
You accept the result
The task is presented for acceptance and deployed in line with the agreed project process.
Scope-change path
A change of scope has its own price and its own approval
If a need arises during delivery to add a feature the quote didn't cover, you'll receive a description of the additional scope and a separate price. An extension doesn't start without your approval.
Fixed price works when a task has a closed scope
A price can be set responsibly only once it's clear what result is to be produced, what delivery depends on and how the task will be accepted.
Not every request can be priced right away. With an unknown cause of a bug, extensive dependencies or no access to the code, we first gather the data needed for analysis.
The price appears once the assumptions are closed. Work begins only after it has been accepted.
Task
Export B2B orders to ERP
Result
Orders from B2B accounts reach the ERP in an agreed format, without manual re-entry.
Dependencies
Acceptance criteria
- A B2B order appears in the ERP within 5 minutes
- A sync error is logged and a notification is sent
- The data format matches the mapping in the attachment
To prepare a quote we most often need:
- the expected business or operational result,
- a description of how it currently works,
- information about the systems and modules related to the change,
- screenshots or a recording of the problem,
- the access needed for analysis,
- the task's acceptance criteria,
- information about deadlines tied to campaigns or company processes.
Whether a task can ultimately be billed fixed price depends on the outcome of the technical analysis.
What work does developing a Magento 2 store cover?
Developing a live store is not only new features. These are the kinds of work we run as single tasks, priced before they start.
Changes to the store interface
Modifications to product cards, product lists, the cart, checkout and other defined elements of the purchase path.
New functionality
Behaviours the store does not have today: sales mechanics, promotion rules, support for new purchase scenarios.
Platform configuration
Settings for the catalogue, prices, taxes, deliveries, payments and store views whose effect can be described unambiguously before the work.
Changes to existing store processes
Rebuilding a working process — order handling, returns, customer accounts or the flow of data between the store's modules.
Integrations with company systems
Exchanging data with ERP, PIM, WMS, CRM or external tools, once the format, direction and error handling are agreed.
Refactoring a specific area
Tidying up an indicated area of code, when the scope and expected result can be closed before work begins.
Documentation and test scenarios
Preparing technical documentation or test scenarios tied to a specific change.
Failures, monitoring and security updates are not on this list — we run those in AURORA CARE.
AI supports the team's work. Responsibility stays with the specialists
AI helps analyse tasks faster, prepare solution variants and handle repetitive parts of the work. It does not make changes to a production store on its own.
The Aurora Creation team is responsible for technical decisions, code, code review, tests, deployment and the final result. How AI is used depends on the type of task and the quality of the current project.
On selected work, AI tools may support:
- requirements analysis,
- finding dependencies in a specific area,
- preparing implementation variants,
- refactoring fragments of code,
- creating documentation,
- preparing test scenarios.
The quality process remains part of delivery regardless of how much AI helped the team.
- Task analysisAI support
- Solution variantsAI support
- ImplementationSpecialist decision
- Code reviewSpecialist decision
- QASpecialist decision
- DeploymentSpecialist decision
In our tests, selected tasks took up to 47% less time
Before launching AURORA EVOLUTION we compared the delivery time of more than 200 real Magento scenarios in a classic process and an AI-assisted one.
up to 47%
less time on selected kinds of work
The highest observed time saving reached up to 47% on selected kinds of work. This does not mean every task will be done 47% faster or priced 47% lower.
The impact of AI depends among other things on the type of task, the quality of the current code, the number of dependencies, the level of customisation and the scope of integrations.
The tests analysed, among others:
- frontend fixes
- small functional changes
- bug analysis
- configuration work
- refactoring code fragments
- technical documentation
- test scenarios
We compared the delivery time of more than 200 real Magento scenarios in a classic process and an AI-assisted one. 47% is the highest observed saving in selected categories, not an average across all tasks. The result depends on the type of task, code quality, the number of dependencies and the scope of integrations.
Start working with us risk-free, up to PLN 5,000
You don't have to commit to an ongoing engagement straight away. Start with 2–3 tasks within a combined budget of up to PLN 5,000, backed by a satisfaction guarantee.
See how we work and how we communicate. If something doesn't click – you don't pay. The risk is on our side.
Once it's done, you can assess:
- the quality of scope preparation,
- the way we communicate,
- the quality of the work,
- the course of testing and acceptance,
- whether the price matches the earlier arrangements.
Before we start, we confirm the number of tasks, the combined value of the stage and the terms on which it ends.
- Task 1priced up frontScope
- Task 2priced up frontScope
- Task 3optionalScope
The test stage covers:
- 1choosing the tasks
- 2accepting the prices
- 3assessing the cooperation
An example development task: automating shipping in Magento 2
Developing a live platform rarely starts with a new feature from a wish list. More often it starts with a chore that takes the team hours every week.
- Problem
- The Willsoor team was handling a growing number of orders, and the repetitive steps around shipping — identifying the carrier, checking the payment, generating the label — consumed time that could go to sales and customer service.
- Scope
- One closed task on the live Magento 2 platform: an autoshipping mechanism handling InPost, DPD and cash on delivery, without touching the rest of the store.
- The change delivered
- Scanning the order code makes the system identify the carrier, check the payment status and generate the label. Handling a shipment no longer means moving between tools by hand.
- Result
- Dispatching a parcel is now one scan of the order code rather than moving between the store panel and the couriers' systems.
- 1 scaninstead of several tools
- 2carriers automated
- Magento 2live platform
Delivered before AURORA EVOLUTION existed as a named model. It shows the scope of development work, not the way it was billed. The figures come from the Willsoor case study.
FAQ — fixed-price Magento 2 development
Here you'll find answers about the scope of the service, changing provider, preparing a task and how the price is set. Maintenance, incidents and monitoring are described separately in AURORA CARE.
There is no single rate, because you pay for a task rather than for time. The price is built after we analyse the scope, the dependencies and the acceptance criteria, and you accept it before work begins. A first engagement can be kept inside a test stage worth up to PLN 5,000 net in total.
We give the date together with the scope and the price, before you accept. It depends on the complexity of the change, the number of dependencies in the code, the testing required and the deployment window agreed for the production store. One example of a closed development task on a live store is the UGC mechanism in the 4Szpaki – EkoTipy case study.
No. We review the code and its dependencies as part of preparing the quote — no separate engagement is needed for that. If access is missing or the cause of a bug is unknown, we come back with questions first. A separate technical audit makes sense only when the whole platform needs assessing, not a single task.
Yes, provided the data format, the direction of the exchange, the frequency and the error handling are agreed. With an unknown API on the other side or no documentation, we start by gathering that information, and the price appears once the assumptions are closed.
AURORA EVOLUTION covers the planned development of an existing Magento 2 store and the pricing of specific tasks before work begins. AURORA CARE is for ongoing maintenance, incident handling, monitoring, updates and SLA cooperation.
A fixed price requires a closed scope, defined dependencies and acceptance criteria. If data is missing at the start, we first come back with the questions needed for analysis. Work begins only after the price is presented and accepted.
The price of the accepted scope stays unchanged. A new feature or a requirement outside the quote receives a separate description and price. The decision to extend is yours.
You don't have to hand over the whole backlog from day one. Cooperation can start with a chosen task, provided we get the access needed to analyse the code and dependencies.
AI can support task analysis, preparing solution variants, repetitive work, documentation and test scenarios. Technical decisions, code, code review, QA and deployment are the responsibility of the specialists.
Failures, monitoring, security updates and response times belong to the scope of AURORA CARE. AURORA EVOLUTION concerns planned development changes.
A new build requires a broader process covering analysis of the sales model, architecture, design, integrations, data migration and launch. Such a project is described on the AURORA ONE page.
Send the task you want to price before work begins
Describe the expected result, add a link to the store and attach materials showing how it works today. We'll come back with the questions needed to close the scope. Sending the form doesn't start work or incur any cost.
