Skip to content

Back-end development

The runtime, meaning the language and platform your server code runs on, is settled by what the system must guarantee and by who will still be changing it in three years. Not by a benchmark. Below is that rule, run across all fifteen pages in this cluster, including the cases where the answer sits outside them.

01Capabilities

Four kinds of server system, and what breaks each one

The back end is where your business rules live, and the rules outlive everyone who wrote them. Four shapes account for most of our custom software development work.

  • Transactional business platforms

    Order management, dispatch and billing, the shape behind our logistics work. Staying correct when two things happen at once matters more than any framework preference.

  • APIs: the agreed way other systems call yours

    We design that agreement first. It is what you cannot cheaply change once three other systems depend on it, and in fintech it is what an auditor reads.

  • Integration between systems never designed to talk

    Warehouse systems, payment providers, monitoring hardware in healthcare. Handling repeats, ordering and reconciliation is the engineering, not the happy path. That is platforms and integration work.

  • Background, batch and scheduled processing

    Queue consumers, imports, exports, nightly reconciliation. What happens on a restart, a cancellation or a half-finished run decides whether these stay boring.

02Stack

Fifteen runtimes, and the ones we would actually reach for

One row per page in this cluster, with our verdict and the honest reason. The whole row is the link. Estate below means the servers and systems you already run.

The fifteen technology pages in this cluster
TechnologyWhen we reach for it
.NET DefaultThe platform and hosting decision for a rule-heavy business system in a Microsoft estate..NET developmentOr book a meeting
C# The languageSame estate, when the question is the code rather than the platform.C# developmentOr book a meeting
ASP.NET Web tierSame estate again, when you are building a web application or the service behind one.ASP.NET developmentOr book a meeting
Java Java estatesThe same system where the servers, the operations and the people are already Java.Java developmentOr book a meeting
Java EE and Jakarta EE Inherited onlyEnterprise Java tied to an application server such as WebLogic or JBoss. Nothing new starts here.Java EEOr book a meeting
Python Data and modelsAnywhere data, analytics or a machine-learning model sits near the core of the product.Python developmentOr book a meeting
Django Business appsThe Python choice when the product is a database-backed application needing staff screens early.Django developmentOr book a meeting
Go ThroughputNetwork services under heavy traffic, where handling many requests at once is cheap.Go developmentOr book a meeting
Rust Hard limitsOnly where a pause for memory cleanup would breach a written response-time limit, and then as one bounded part.Rust engineeringOr book a meeting
PHP ModernizeAn estate that already earns money: raise the versions, test the paths that take money, then restructure.PHP modernizationOr book a meeting
Laravel New PHP workThe answer to what to build new in PHP, and not the answer to what to rewrite.Laravel developmentOr book a meeting
Yii2 Maintain onlyA live application people are nervous about touching. Keep it current and tested; start nothing new on it.Yii2 maintenanceOr book a meeting
Ruby and Rails Keep what runsA working Rails application is worth keeping. We extend and maintain rather than replace.Ruby and RailsOr book a meeting
C++ Engine workProcessor-heavy work inside an ordinary application, or one native library several languages must call.C++ developmentOr book a meeting
C Bare metalFirmware, drivers and vendor toolchains where memory is counted in kilobytes. On a full operating system we argue for C++.C developmentOr book a meeting

03Fit

Two questions settle a runtime, and sometimes the answer is the one you run

What must this system guarantee, and who is still changing it in three years. Those two settle most cases inside one call. Nothing we earn depends on which runtime you choose, so the answer follows your system, and half the rows below keep the language you already run.

Six situations, and what we would tell you in each
Your situationWhat we recommend
A rule-heavy transactional core in a Microsoft estate, expected to outlive its team .NETTake the platform decision first, then the code. For a web application the answer is ASP.NET. Three different bills, and people arrive calling all of them one name.
The same system, but the servers, operations and people are already Java JavaSpring Boot, which is what most Java teams already run. Changing platform to fix a working estate almost never pays.
Data, analytics or a machine-learning model anywhere near the core of the product PythonNot a close call. If it is really a database-backed business application needing staff screens early, the framework is the decision and that is Django.
A product that spends its time waiting on a database or a third party, and one team writing TypeScript Outside this clusterOne language across the whole stack beats a faster runtime in a small team. Node.js sits under web development here, not in this cluster.
A PHP or Rails application that already earns money and is slow to change Modernize in placeRaise the versions, test the paths that take money, then reshape what is there. That is legacy modernization, and a rewrite is the expensive route to the same place.
Everything feels slow, and the language is getting the blame Keep the languageLook first at how the database is queried, at work done while the caller waits that should be queued, and at releases that force everything out together.

Scope

A language nobody on your staff can maintain costs more in year two than it saves in month one. The slowness people blame on a language usually sits in the three places named above, all fixable where they are. What we own is the design and what follows from it: the rules the system enforces, what it does when something fails, the line between one service and the next, and whether your engineers can keep changing it after we step back. We work to ISO 27001:2022 and ISO 9001:2015, audited by Quay Audit UK. unicrew has been building software since 2012, as Artelogic until the rename, with 100+ senior in-house engineers across six countries and 120+ projects delivered across 12 countries.

We pick a runtime from what the system has to guarantee and who will still be changing it in three years. Those two questions settle most cases inside one call. We write the decision down, with what we rejected and why.

Oleksandr TrofimovChief Technology Officer, unicrew

04Delivery

Guarantees first, runtime last

Four steps, usually inside an hour. The runtime comes last because it is the cheapest of the four to change later, and we write the result down: the reason is the first thing to get lost.

  1. Establish what the system has to guaranteeCorrectness, speed, volume, audit trail and where data is allowed to live, written as constraints rather than preferences. In a regulated sector the regulator sets them, not you: GDPR in the EU, and the sector rules above it. Most back-end arguments are two people optimising for different guarantees without saying which is in the contract.
  2. Look at what you already run, and who maintains itThe existing estate, the operations team you have, and the hiring market where the system lives. This decides the answer most often, and it is the input people skip in favour of a comparison table.
  3. Fix the boundaries before the runtimeWhat this service owns, what it never touches, what it exposes to others. Boundaries cost far more to change later than the language inside them does.
  4. Write the decision down, including what we rejectedOne page: the choice, the constraints it satisfies, what we turned down and why. It is also what makes an independent verdict possible later, which is what a quality audit is for.

05Trust

What changed for clients after the back end did

  • 15-20%Increase in revenueA paddle sports centre in California, client-reported, after we modernized their platform on PHP, Yii2 and Java.
  • 600+Businesses using the platformBooked It, on the Laravel back end we built for them.
  • 2xData-entry throughputA custom recognition tool we built in C#.

06Case studies

Six back-end systems, and the outcomes published with them

07Client voices

Five clients, in their own words

See our client reviews

08Questions

The questions buyers put to us before signing off a runtime

You can bring our engineers into your team, and when you own the roadmap that is often the right shape. Every engineer comes with ownership of the design, because the decisions that cost most to change here are what each part owns and how it reaches the data: an architect outside the delivery team reviews the design, and the work goes through the same QA practice as our own. Team extension is managed teams.

Yes, and the sequence is the same whatever the language. We map what actually runs rather than trusting the handover pack. We put tests around the behaviour that pays your bills before changing any of it. Then we bring the language and library versions up to date, because nothing else can move until that is done. The first weeks go into that groundwork, which is what lets later changes land safely.

Most of the sequence above exists for this. Every runtime and boundary decision is written down with what we rejected, so the reasoning does not leave with a person. An architect outside the delivery team reviews the design, so more than one person can explain the system. And the behaviour that pays your bills sits in tests rather than in somebody's memory.

If the system already exists, by asking for read access to the repository first: an hour inside the code moves an estimate more than three hours of description. The call is then with an engineer who has read it. What comes back is written: the recommendation, what we would change first, what we would leave alone, and what we rejected. Work usually starts two to four weeks after we agree scope.

Not sure which runtime your system belongs on?

Tell us what the system has to guarantee, what it talks to, and what your team already writes. You will get an engineer's read on the choice, including the version where the language was never the decision.

Book a scoping call

Thank you

Thanks for your message. We will get in touch with you shortly.