Forward Deployed Engineering
ZSoftly engineers join your team and stay until the platform runs in production. Then your team takes it over.
Overview
Infrastructure programs stall between pilot and production. The hardware is racked and the design has approval, but nobody owns the final work: identity, networking, security review, observability and day-two runbooks.
Forward Deployed Engineering puts a small ZSoftly team inside your organization to own the production work. Our engineers join your stand-ups, commit to your repositories and work under your change process. You sign off on one outcome in the first week, and we report progress against it.
The engagement ends when your engineers run the result without us. We commit code, pipelines and runbooks to your accounts from the first day.
What this service covers
- One written outcome and its success criteria, set in week one
- ZSoftly engineers working in your repositories and on your tools
- Production go-live with monitoring, security review and runbooks
- Pairing with your engineers from the first week
- A documented handover, with your team running the platform
Where infrastructure programs stall
Programs stall between a working design and a service your team runs.
Hardware waiting on integration
You racked and paid for the servers. Your team still solves storage, networking, identity and multi-tenancy one ticket at a time.
Pilots stuck before production
A proof of concept works in a sandbox. Nobody scoped the security review, the monitoring or the upgrade path, so it never ships.
Consultants who leave with the knowledge
An integrator builds the platform and moves on. Your team inherits a system it does not know how to change. Each fix means a new contract.
Embed, build, ship, hand over
Four phases, one accountable team. Your engineers pair with ours in every phase.
Embed
01A small ZSoftly team joins yours and learns the real constraints: network layout, identity, change control, data rules and who signs off.
Build
02We ship infrastructure as code, pipelines, integrations and automation in cycles of one to two weeks, inside your repositories and under your review process.
Ship
03The outcome goes live with monitoring and alerting, a security review, backups, an upgrade path and tested runbooks.
Hand over
04Your engineers take the on-call rotation while we are still on the team. We leave when they run changes, upgrades and incidents without us.
Two roles, one accountable team
ZSoftly engineers staff every engagement. We do not white-label another integrator.
Forward deployed engineer: builds in your environment
- Private cloud, virtualization and bare-metal automation
- Kubernetes platforms and GitOps delivery
- CI/CD pipelines and infrastructure as code
- Identity, zero trust networking and secrets management
- Model serving, AI agents and data pipelines
- Migration off legacy virtualization and hosted platforms
Engagement lead: runs the program with your stakeholders
- Defines the outcome and success criteria with you
- Aligns security, compliance and procurement early
- Reports progress against the outcome every week
- Owns the enablement plan and the handover
- Escalates blockers to the people who own the decision
Outcomes we deploy
Each engagement targets one of these outcomes, on your hardware, your cloud account or ZCP.
Private and sovereign cloud bring-up
A self-service private cloud on your hardware, with compute, storage, networking, tenants and quotas your team operates.
Migration off legacy virtualization
Move workloads off VMware or an aging hosted platform in planned waves, with a rollback plan for each wave.
Production Kubernetes platforms
Clusters with GitOps delivery, ingress, policy, observability and an upgrade process your team has already rehearsed.
AI workloads in production
Take inference services and AI agents from a pilot to production, with access controls, audit logs, cost limits and monitoring.
Regulated and data-resident workloads
Keep data in Canada or in your own facility, and keep access, logging and change records ready for your audit.
Team enablement
Pairing, working sessions and written runbooks, so the skills stay inside your team after the engagement closes.
Recent engagements
Zenphry Business Suite
Two ZSoftly engineers joined Zenphry to build its business suite: CRM, accounting, HR, helpdesk and governance on the Frappe suite, with Zitadel for sign-in.
Runzivo
One ZSoftly engineer worked with the Runzivo team to build its managed CI runner platform. Runzivo had a working platform in under two months, now in Early Access.
What we learn in the field goes back into the product
When an engagement exposes a gap in ZCP, the ZCP CLI or the Terraform provider, we fix it in the product. You get the fix in a normal release, like every other customer.
No customer-only forks
We write code for your environment with open standards and public tools. Your team maintains it after we leave.
Open-source foundations
ZCP and the platforms we deploy build on open-source software. You inspect, extend and move it, and you keep the option to leave ZSoftly.
Engagement models
Every engagement starts with a written scope and a fixed price for the first phase. We review longer programs against the outcome at each milestone.
Architecture Workshop
Start with a free discovery call. We agree the outcome, map your environment and plan the deployment.
- Outcome definition and success criteria
- Target architecture and risk list
- Optional pilot of the riskiest part
- Deployment plan and fixed quote
Deployment pod
A small team takes one outcome from plan to production and trains the people who will own it.
- A production service
- Infrastructure as code and pipelines
- Runbooks and on-call handover
- Trained owners on your team
Embedded program
Several pods across sites, regions or business units, renewed every quarter against a shared roadmap.
- Program roadmap and milestones
- Multiple outcomes delivered in sequence
- A platform team running without us
- Optional move into managed operations
Questions teams ask before they start
How is this different from staff augmentation?
With staff augmentation you buy hours and own the outcome. Here, a ZSoftly team owns one agreed outcome, plans its own work against it and hands over a running platform.
How is it different from a fixed-scope project?
A fixed-scope project fixes the design up front and delivers it to you. Forward deployed engineers work inside your team, adjust as the real constraints appear, and train your engineers as they build.
Do we have to run on ZCP?
No. We deploy on your hardware, in your public cloud accounts or on ZCP, or on a mix of them.
Who owns the code and the infrastructure?
You do. We work in your repositories and accounts from the first day. The code, pipelines, credentials and runbooks we build for you stay with you when the engagement ends. ZCP, the ZCP CLI and the Terraform provider keep their own licences.
Can you work in restricted or offline environments?
Yes. We work under your access policies, on your devices or through your VPN. Tell us about offline or restricted environments on the scoping call, and we plan delivery around them.
What happens after the handover?
Your team runs the platform. If you prefer, ZSoftly managed operations take over under a service level agreement.
Scope an engagement
Tell us the outcome you need in production. After a scoping call, an engineer sends you a written plan.