Websites, stores and apps
Ongoing fixes, small content and feature changes, new pages, and checks on forms and checkout flows. We work with WordPress, WooCommerce, MedusaJS, Shopify, and apps built on Next.js and Node.js.
Outsourced IT
IT support for businesses without an IT department.
We take ownership of the 4 layers your sales run on: websites, online stores, apps and servers.
One team handles your updates, backups, SSL certificates, deployments and tickets, so you can focus on running your business.
Overview
We look after the systems your sales run on.
When everything runs smoothly, infrastructure maintenance goes unnoticed. You notice it on the day an SSL certificate needs renewing, an update has to go out safely or the server disk needs more space. We handle all 3 ahead of time, so you always know where the access credentials are, who is responsible for the code and that a current backup is ready to restore.
We start by documenting what you actually have, then put 4 basics in order—backups, deployments, monitoring and access—and build ongoing maintenance on that foundation. When you send a ticket, it goes straight to the developer who can resolve it, because we write the code ourselves. One contract covers the work previously split between an IT department, several freelancers and your hosting provider’s support desk, so everything sits in one place.
Server under control
VPS, nginx, services that start on boot, cron jobs, monitoring.
Auto-renewing certificates
Let’s Encrypt with automatic renewal and a check that each renewal succeeded.
Deployments you can roll back
Git, builds in an isolated environment, rollback to the previous version.
A single point of contact
Tickets with priorities, an agreed order of work and status updates.
What ongoing IT maintenance covers.
We cover 6 areas, from the application layer down to the server and domain, and tailor the scope to what you actually have running.
-
-
Servers and infrastructure
VPS setup and maintenance: nginx, auto-renewing SSL certificates, services that start automatically after a reboot, cron jobs, log rotation, disk space and basic uptime monitoring.
-
Deployments and repository
Git and GitHub serve as the single source of truth for your code. We build in an isolated environment, test before every release, deploy to production and roll a change back fast if it causes an issue.
-
Updates and backups
We test operating system, dependency and plugin updates on a staging copy before they reach production. Automatic file and database backups are stored off the production server, and a periodic test restore confirms you can recover from them whenever you need to.
-
One ticket channel
All requests arrive in one channel, so each one stays visible and traceable from start to finish. Every ticket gets 3 things—a priority, an owner and a status—so you can see what’s in progress and what’s next in the queue.
-
Incident diagnostics
When a store stops accepting orders or a site won’t load, we follow a fixed sequence of 4 checks: server logs, application logs, the latest deployment and integrations. We restore service first, so your sales resume as quickly as possible, and then fix the root cause.
Migrations and cutovers
Domain migrations with zero downtime.
Changing your domain, moving a site to a new server or splitting the admin panel from the backend are delicate operations that depend on DNS settings (how a domain points to a server), SSL certificates and URLs stored in the database. When we run a migration, we follow a tested plan, so your site stays online for the entire cutover.
We prepare the cutover plan in advance: we lower the TTL on DNS records, issue SSL certificates for the new addresses before the switch, run the target environment in parallel and test it on a temporary URL. Then we update the DNS records, replace URLs in the database, set up redirects from old paths and verify that certificates auto-renew. We check email and the sending setup (MX, SPF and DKIM records) as a separate step, so incoming and outgoing mail keeps flowing throughout the migration.
- VPS
- nginx
- DNS
- Cloudflare
- Let's Encrypt
- certbot
- MySQL
- PostgreSQL
Priorities
Clear priorities for every ticket.
We sort every ticket into 4 priority levels, and anything blocking your sales goes first, so you always know what to expect.
| Priority | What it means | Response |
|---|---|---|
| Sales-blocking outage | The site or store is down, checkout rejects orders, payments don’t come through, or the admin panel is unavailable to the whole team | Top priority: we start immediately and send progress updates until service is restored |
| Partial failure | The system is up with some features affected: a form stops submitting, an integration misses status updates, or an error shows on certain devices only | Goes ahead of development work; if a fix takes time, we set up a workaround first |
| Improvement | A new page, a content change, an extra field in the admin panel, a small design tweak, optimization | Scheduled in the current work cycle, in an order we agree on with you |
| Consultation | A question about technical direction, choosing a tool, estimating an idea, or a second opinion on another vendor’s proposal | We answer as part of day-to-day contact; for larger topics, we send a written recommendation by email |
Standard
What we leave in place in your infrastructure.
Our maintenance rests on the 10 foundations below, which keep your system stable and make issues less frequent over time.
- Code in a Git repository with full change history—you can see who changed what and when
- Builds and tests in an isolated environment before every production deployment
- Automatic backups of files and databases, stored off the production server
- SSL certificates that renew automatically, with a check that each renewal succeeded
- Services that restart on their own after a server reboot, with every cron job documented
- Secrets and API keys stored in the server configuration, outside the repository and frontend code
- Named access for each person, so you can revoke one person’s access without resetting everyone’s password
- Uptime monitoring with an alert when a service stops responding
- An inventory of environments, domains, integrations and every place your data is stored
- You own the code, domains and accounts, which keeps you fully independent of us
- Git / GitHub
- VPS
- nginx
- systemd
- CRON
- WordPress
- WooCommerce
- MedusaJS
- Next.js
- Node.js
- PHP
- PostgreSQL
Process
We take over projects from other vendors.
A common scenario: the system works, but knowledge of how it’s built and where the credentials are is scattered. We start with the 4 steps below to put the facts in order, so you get the full picture.
-
01
Inventory and access
We document what’s actually running: domains and their registrars, servers, databases, repositories, third-party service accounts and integrations. We reorganize access so it belongs to your company and stays under your control, even when your team changes.
-
02
Current-state audit
We review versions and updates, backups and whether they can be restored, server configuration, certificates, performance and basic security: secrets in the repository, input validation and permissions. You get a list of risks ranked by priority, so you know which ones to address first.
-
03
Cleanup
We first secure the 4 essentials for business continuity and data security: backups, certificates, keys and deployments you can roll back. The code moves into a Git repository, so every change is reviewed and traceable.
-
04
Ongoing maintenance
Then we switch to ongoing mode: prioritized tickets, scheduled updates, monitoring and a regular summary of completed work. Feature development and maintenance run as 2 parallel tracks, so new features keep shipping in iterations.
Engagement models
Prepaid hours, a retainer or a single project.
Three billing models, each with the same transparent report: a list of tasks with the actual time spent, so you know exactly what you’re paying for.
Prepaid hours
For companies with irregular needs that want developer time reserved without a long-term commitment.
- A pool of hours to use on any kind of work
- Billing with a list of tasks and time spent
- Small changes, fixes and technical consultations
- Request changes as you need them, with no separate order for each one
- A good starting point if you’re working with us for the first time
Ongoing maintenance (retainer)
For companies whose revenue depends on their store or app being up. We take responsibility for the whole setup, so you have one team keeping everything running.
- Maintenance of the server, certificates, backups and scheduled jobs
- Operating system, dependency and plugin updates tested outside production
- Prioritized tickets with an agreed order of work
- Uptime monitoring and response to sales-blocking outages
- A pool of development hours in every billing cycle
- A periodic summary of completed work and technical health
One-off project
For companies that have an in-house team or a specific task with a clear start and finish, and need someone to see it through.
- Domain or server migration, or an environment cutover
- Security, performance and technical debt audit
- Cleanup of deployments and the repository
- Code review and architecture consulting for in-house teams
- Fixed scope and timeline, with documentation handed over at the end
FAQ
Questions about IT support.
You didn’t build our system. Will you still maintain it?
Yes, that’s a common situation. We start with an inventory and an audit, so we know the actual state of the system before we take responsibility for it. After the audit, you get a list of risks and a proposed maintenance scope. If the code needs significant repairs, we tell you directly and show what has to be fixed before ongoing maintenance begins.
Do you offer a contract with guaranteed response times?
We set 4 priority levels and clear rules for the order of work, tailored to your situation. A sales-blocking outage has top priority, and we start on it immediately. Development requests are scheduled in the current work cycle. If you need formal availability terms (an SLA), we agree on them individually as part of the ongoing maintenance scope.
Who owns the code, domains and server?
You do. We register or transfer domains and hosting accounts to your company, and the code lives in a repository you have full access to. If you decide to end the engagement, we hand over access and documentation smoothly, because you remain the owner of your system the entire time.
We have our own developer. Does working with you still make sense?
Yes, and it’s a common setup. We step in where your team needs extra time or expertise: infrastructure and deployments, integrations, performance and hard-to-trace production bugs. We also do code review and architecture consulting before a major technology decision. We work in your Git repository and follow your team’s process.
What happens if an update breaks the site?
We test every update in an isolated environment before it reaches production. Every deployment is reversible: if a problem appears, we roll back to the previous version first and investigate the cause afterward. Before every major operation, we back up the database and files.
Do you also handle email and office hardware?
We focus on the layer your sales run on: servers, domains, apps, online stores and integrations. We do handle business email setup and sender authentication records (SPF, DKIM, DMARC), because they’re part of your domain infrastructure. Computer repair and office networks are outside our scope.
Ongoing care for your IT.
Email us what you have running and what needs the most attention. Within one business day, we reply with questions, then review the current state and propose a maintenance scope.