How long does a custom system take to build?

A pilot delivers working software in 4–8 weeks. A full enterprise system (ERP, CRM, complete platform) typically reaches production in 4–6 months. Modernization projects vary widely depending on legacy system complexity. We never promise a date we can't hit.

Can you modernize our legacy system?

Yes — that's a core capability. We do strangler-fig migrations, not big-bang rewrites. The legacy system stays running while we incrementally extract functionality into a modern stack. Most clients see the first migrated module in 6–8 weeks, with full migration over 6–18 months depending on scope.

You do. All deliverables — source code, infrastructure-as-code, documentation, test suites, deployment pipelines — are transferred to your team under your IP. We retain the right to use generic, anonymized techniques in future engagements.

Do you maintain the system after launch?

Yes. We offer ongoing operations contracts: monitoring, on-call SLAs, incident response, security patching, feature work. Or we can hand off cleanly to your internal team with documentation and a knowledge transfer. Your call — both options are valid.

Will you replace our internal team?

No. We work alongside internal teams as a senior engineering augmentation. The best outcomes happen when your team owns the product knowledge and we own the engineering execution. We embed, document everything, and transfer skills as we go — the goal is for your team to operate the system confidently.

01 — Software Engineering

Software is infrastructure.

Built to outlast the team that built it.

We don't ship MVPs and disappear. We engineer custom systems — SaaS platforms, enterprise backends, APIs, real-time systems — that run reliably for years. Senior engineering team, international delivery, no subcontracting.

Book a discovery call See what we build

production.log

$ git log --oneline | head -1

8bb50e5 feat: production deploy v4.2.1

$ uptime

99.987% over 14 months

$ kubectl get pods

api Running 847d

worker Running 847d

scheduler Running 847d

ingestor Running 847d

02 — Watch

How we engineer.

How we engineer

03 — Principles

Three principles. We don't compromise on them.

We don't ship MVPs and disappear.

We don't customize Odoo and call it ERP.

We engineer systems that run for a decade.

04 — What we build

Five system types, engineered end-to-end.

Custom software covers a wide range. Here's what we actually deliver, with real examples of each.

SaaS & Platform Engineering

Multi-tenant SaaS platforms designed for scale from day one. Tenant isolation, billing, auth, admin, analytics — engineered as a coherent system, not bolted together from templates.

─Multi-tenant SaaS platforms with strict tenant isolation
─Subscription billing systems with Stripe, Lemon Squeezy, or local payment integrations
─Admin consoles, customer portals, and tenant onboarding flows
─Usage metering, quota enforcement, and per-tenant analytics
─Single sign-on (SSO), SAML, OAuth, and enterprise auth integrations

Enterprise Backend Systems (ERP · CRM · HRMS)

Custom enterprise systems built from scratch — not Odoo customization, not SAP add-ons. We design the data model around your operations, not the other way around.

─Custom ERP systems — inventory, finance, procurement, HR, manufacturing modules
─Custom CRM systems — pipeline, contacts, lead scoring, integrations with email and telephony
─Custom HRMS — payroll, attendance, performance reviews, leave management
─Industrial / SCADA software — production-floor integration, MES, OEE dashboards
─Government / public-sector e-services with strict compliance and audit trails

APIs & Microservices

REST, GraphQL, gRPC. Internal service meshes, external developer APIs, B2B integrations. We design APIs that your future engineering team will thank you for.

─REST and GraphQL APIs for mobile and web clients
─Microservice architectures with clear service boundaries and contracts
─B2B integration APIs with rate limiting, authentication, and developer documentation
─Internal service-to-service communication with gRPC and event buses
─API gateways, edge functions, and multi-region routing

Real-time & Event-Driven Systems

Systems where latency matters and events arrive faster than you can poll. Kafka, NATS, WebSockets. Built for throughput and ordered delivery.

─Real-time dashboards and live monitoring systems
─Event-driven architectures with Apache Kafka or NATS
─WebSocket-based collaboration features and live notifications
─High-throughput data ingestion pipelines with backpressure handling
─CQRS and event sourcing for audit-heavy domains (finance, healthcare, government)

System Modernization & Migration

Legacy systems on PHP 5.6, .NET Framework, or 15-year-old Oracle databases. We migrate them incrementally — strangler-fig style — without big-bang rewrites that fail.

─Strangler-fig migrations from monoliths to microservices
─Database migrations (Oracle → PostgreSQL, MySQL → PostgreSQL, etc.)
─Lift-and-shift to Kubernetes with zero downtime
─Frontend modernization (jQuery → React/Next.js, AngularJS → Vue/React)
─API extraction from monoliths and gradual decomposition

05 — How we engage

Three steps. We refuse what we can't ship.

Discovery

1–2 weeks · fixed price

We sit with your team, understand the operational problem, audit existing systems and data, identify the right architecture, and scope a paid pilot with measurable success criteria. Output: written engagement brief and a fixed-price pilot SOW.

Pilot

4–8 weeks · fixed scope, fixed price

Proof of value on real data. The first system module is built, deployed behind a feature flag, and validated against business metrics. You get working software, source code, documentation, and a clear go/no-go decision.

Production & Operations

Ongoing

Once the pilot proves value, we engineer for production: monitoring, on-call, incident response, deployments, scaling, security. We stay as a long-term engineering partner — not a hand-off.

06 — Proof

Numbers we can defend.

0.000%

Production uptime

Longest-running system

5.0

Clutch verified rating

They built our ERP from scratch in six months. Two years later it's still running without a single Symloop engineer on-call. That's the bar.

— IT Director, Industrial group, Algeria

07 — Tech we use

Mature, boring, production-grade.

We use the same tools the best engineering teams in the world use. No experimental libraries, no half-maintained packages — only mature, production-tested infrastructure.

stack.config.ts

// SYMLOOP / SOFTWARE ENGINEERING

languages:TypeScript · Python · Go · Rust · Java · .NET

runtimes:Node.js · Bun · CPython · JVM · .NET CLR

backends:NestJS · FastAPI · Django · Spring Boot · Express

data:PostgreSQL · Redis · MongoDB · Elasticsearch · ClickHouse

streaming:Apache Kafka · NATS · RabbitMQ · Redis Streams

infra:Docker · Kubernetes · Terraform · Pulumi · Helm

ci_cd:GitHub Actions · GitLab CI · ArgoCD · Flux

cloud:AWS · GCP · Azure · Vercel · Cloudflare

observability:Prometheus · Grafana · OpenTelemetry · Sentry · Loki

testing:Jest · Pytest · Playwright · k6 · Vitest

08 — FAQ

Common questions.

Answer

How much does a custom system cost?

Custom software pricing depends on scope, integration count, and production SLAs. Typical engagements start at €30K for a focused pilot and scale up to multi-year retainers for enterprise systems. We start with a fixed-price discovery (1–2 weeks) followed by a fixed-price pilot (4–8 weeks). The discovery delivers a transparent quote — no estimate-by-vibes.

09 — Talk to us

Have a system worth building? Let's start with a 30-minute call.

Book a discovery call

— Related

Related disciplines

Insights from this practice

All insights