// executive.summary
Executive Summary
Jeff Hojka needed to host the public web portal for The Marathon System — a Clarion/NetTalk Windows-native web server — on a cloud VPS. The problem: every Windows installation consumes approximately 65 GB of SSD space, making it impossible to fit onto an affordable 70 GB OVH VPS. The solution was unconventional: deploy the Windows application on Ubuntu Linux using Wine, a Windows compatibility layer that runs native .exe files without a Windows license or a Windows installation.
The result was a server that freed roughly 30 GB of SSD space, avoided a second Windows 10 license, and — most significantly — made it possible to retire a $270/month business internet connection that existed solely to provide static IP addresses. The new OVH VPS costs $5 per month. The office is now 100% cloud-based, and Jeff works remotely from home internet like any cloud-first developer.
About the Architect: Jeff Hojka
Founder of Khojant LLC and architect of The Marathon System — a cloud-hosted insurance office suite serving independent agencies since 1982. Jeff brings 35+ years of software engineering experience across Clarion, C/C++/C#, AWS, and Linux infrastructure, including an early background in Microsoft Xenix that gave him the Unix instincts to bridge a 25-year gap back to Linux with confidence. This project is a direct demonstration of that background applied to a real infrastructure cost problem.
// the.problem
The Problem: Three Constraints, One Server
The Marathon System includes a customer-facing online portal — a secure web application built with Clarion and NetTalk (Capesoft's web server component). Like all Clarion-built software, it compiles to a Windows-native executable. Running it requires a Windows environment.
For years, this web server ran on a machine sitting in Jeff's office, connected to the internet via a business-grade connection. That connection cost $270 per month — and the only reason it existed was to provide static IP addresses needed for reliable inbound connections. The application itself worked fine. The hosting model was simply expensive.
Moving to an OVH cloud VPS was the obvious fix: low cost, static IP included, managed infrastructure. The obstacle was the SSD.
⚠ The SSD Problem
A full Windows 10 installation consumes approximately 65 GB of SSD space before a single application is installed. The target OVH VPS had a 70 GB SSD. That leaves roughly 5 GB for the operating system overhead, the application, its data files, and room to breathe — not a viable margin for a production web server. A second Windows license on top of the tight disk space made the all-Windows route a dead end at the $5/month tier.
The constraints stacked up clearly:
- SSD space: Windows installs consumed ~65 GB, leaving almost no room on a 70 GB VPS disk.
- Licensing: A second Windows 10 license would be required for the VPS — both machines in the setup were already running Windows 10.
- Application rewrite: The Clarion/NetTalk application was production software. Porting it to a native Linux stack was not on the table.
- Budget: The business internet bill was $270/month. Any solution that cost meaningfully more than $5/month would undercut the savings.
// the.insight
The Insight: More RAM Than SSD
The key realization was asymmetric: Jeff had more RAM available than SSD space. Wine — the Windows compatibility layer for Linux — runs Windows executables without a Windows installation, but it carries one known cost: it requires roughly twice the memory of a native Windows deployment. For this application, that meant moving from a 2 GB requirement to 4 GB.
Windows on VPS
65 GB
SSD consumed by OS install alone — leaves ~5 GB on a 70 GB disk
→
Ubuntu + Wine
~35 GB
~30 GB freed up — plenty of room for the app, data, and growth
The trade-off was accepted deliberately: surrender RAM (which was abundant) to recover SSD space (which was the actual bottleneck). Ubuntu Linux with a minimal Xubuntu desktop environment brought the OS footprint down dramatically, making the 70 GB VPS not just viable but comfortable. The memory doubling — from 2 GB to 4 GB — was a cost Jeff had more than enough capacity to absorb.
✓ The Trade-off in Plain Terms
What you give up: Wine requires approximately twice the RAM of a native Windows deployment — 4 GB instead of 2 GB for this application.
What you get back: ~30 GB of SSD space, zero Windows license cost, and a server small enough to run on a $5/month VPS — clearing the path to retire a $270/month business internet bill.
// the.solution
The Solution: Ubuntu + Wine + nginx
The deployment was structured in three phases, each building on the last, following a guide Jeff developed and published on the ClarionHub community forum in January–February 2025.
Phase 1 — Provisioning Ubuntu on OVH
1
Xubuntu 25.10 Minimal
A lightweight GUI distribution was chosen specifically because Wine requires a desktop environment to function. The minimal install kept the disk footprint down without sacrificing Wine compatibility.
2
OVH Networking Quirks
OVH requires a MAC address to be registered in its control panel before a static IP can be assigned. Network configuration during the Xubuntu installer caused boot timeouts — the documented fix was to skip networking at install time and configure it afterward via Advanced Network Settings and a netplan YAML file with an on-link: true routing directive.
3
Wine + Winetricks
Wine was installed with 32-bit architecture support enabled (wine32:i386) and Winetricks added to manage Windows runtime dependencies. A key troubleshooting note: if Wine throws a "unable to load kernal32.dll" error, moving the ~/.wine folder aside lets Wine rebuild its configuration cleanly.
Phase 2 — Deploying the Clarion/NetTalk Application
4
File Transfer via WinSCP
Application files were uploaded over SSH using WinSCP (a familiar Windows-side tool) and moved into ~/.wine/drive_c/ — Wine's emulated Windows C: drive. From Linux's perspective, the application thinks it's running in a standard Windows file system.
5
First-Run Troubleshooting
The application appeared to freeze on first launch. The root cause: existing XML, JSON, and INI configuration files contained port settings from the old environment. Removing those files let the application start fresh and prompted for correct settings — a subtle but important gotcha for anyone migrating an existing deployment.
6
Port Configuration
Wine cannot bind to privileged ports (80 and 443). The application was configured to listen on port 8080 (HTTP) and 8443 (HTTPS). A shell script (web1.sh) was created to launch the application from its own directory (ensuring relative file paths resolved correctly), made executable with chmod +x, and added to Xubuntu's Session and Startup manager for automatic launch on login.
Phase 3 — nginx Reverse Proxy and SSL Passthrough
7
HTTP Reverse Proxy
nginx was configured to listen on port 80 and proxy all traffic to 127.0.0.1:8080. Standard proxy headers (Host, X-Real-IP, X-Forwarded-For, X-Forwarded-Proto) were set to preserve client information correctly.
8
SSL TCP Passthrough
Because the Clarion/NetTalk application manages its own SSL certificates, nginx was configured in stream (TCP passthrough) mode rather than terminating SSL. This required installing libnginx-mod-stream and configuring a streams-enabled directory. The stream block uses ssl_preread to route HTTPS traffic by SNI hostname directly to port 8443.
9
Visual C++ Runtime
The vcrun2015 Visual C++ 2015 runtime was installed via Winetricks to satisfy a dependency of the Clarion application. This is the Wine equivalent of installing a Windows runtime redistributable — a one-command fix once identified.
// cost.analysis
The Numbers: Before and After
Before — Office Internet
$270
Per month for business-grade internet with static IPs. The application ran on a physical machine in the office. The static IPs were the only reason this connection existed.
After — OVH Cloud VPS
$5
Per month for an OVH VPS with a static IP included. Ubuntu + Wine handles the application. Zero business internet bill.
| Item |
Before |
After |
Delta |
| Monthly hosting / connectivity cost | $270 | $5 | −$265/mo |
| Annual hosting cost | $3,240 | $60 | −$3,180/yr |
| Windows licenses required | 1 (office PC) | 1 (office PC only) | −1 license |
| SSD consumed by OS | ~65 GB (Windows) | ~35 GB (Ubuntu+Wine) | −30 GB |
| Required RAM | 2 GB | 4 GB | +2 GB |
| Static IP dependency on office | Yes | No | Eliminated |
| Office internet required | Yes ($270/mo) | Home internet | 100% cloud |
| Application code changes | — | None | Zero rewrite |
The memory increase — from 2 GB to 4 GB — is the only genuine cost. Everything else is a gain. The RAM was available on the chosen VPS tier. The SSD was the hard constraint, and Ubuntu + Wine solved it cleanly.
// key.insights
Key Insights and Lessons Learned
1. Identify your actual bottleneck
The problem was never the application — it was SSD space and licensing. Once the real constraint was identified, the solution became obvious: use a smaller OS. Ubuntu with a minimal GUI desktop consumes roughly half the disk space of a Windows installation, and Wine runs the application as-is on top of it. This is infrastructure thinking, not application thinking.
2. Wine is production-capable with the right architecture
Wine's limitations are real but workable. The inability to bind to privileged ports (80/443) is cleanly solved by nginx acting as a front door. The doubled memory requirement is a known trade-off that can be planned for. The pattern — Wine handling application logic, nginx handling public-facing traffic — is repeatable for other Windows web applications and repeatable in other environments.
3. Cloud providers have undocumented quirks
OVH's requirement to register a MAC address in its control panel before assigning a static IP, and the need for an on-link: true routing directive in netplan YAML, are exactly the kind of hard-won details that don't appear in any general tutorial. Documenting them — as Jeff did on ClarionHub — is a meaningful contribution to the developer community.
4. Prior Unix instincts transfer even after decades away
Jeff's background included Microsoft Xenix in the late 1990s — followed by 25+ years entirely in the Windows ecosystem. Returning to Linux revealed that the foundational concepts transferred: directory structures, file permissions, process and port thinking, configuration files. The Xenix background made Linux navigable rather than alien, compressing what could have been a steep learning curve into a practical deployment project.
5. AI as a knowledge bridge, not a replacement for expertise
AI assistance was used throughout the process to translate Windows concepts to Linux equivalents, diagnose errors, and generate configuration file templates — targeting specific problems in context rather than working through hundreds of pages of documentation. The speed gain was significant. But the judgment calls — which approach to take, which trade-offs to accept, when the output was right — required the domain and infrastructure expertise Jeff brought to the project.
6. Checkpoints as a safety net
Hyper-V VM checkpoints were used at stable milestones throughout the setup. This is the same methodical approach anyone accustomed to working from detailed manuals would take — build in recovery points before each risky step. It costs nothing and prevents hour-long rollback exercises.
// outcome
Outcome
The Clarion/NetTalk web portal for The Marathon System now runs on an OVH cloud VPS for $5 per month, hosted on Ubuntu Linux with Wine handling the Windows-native application and nginx managing public HTTP/HTTPS traffic. The application launches automatically on system boot. SSL passthrough preserves the application's own certificate management. The server handles production traffic without modification to the application code.
More significantly: Jeff's office is now 100% cloud-based. The business internet connection — which existed solely to provide static IP addresses — has been retired, eliminating $270 per month in overhead. Jeff now works from home internet as a remote worker, connecting to all systems through the cloud infrastructure he built.
The full three-part guide was published on ClarionHub in January–February 2025 and received community engagement, marking a practical, reproducible path for other Clarion developers considering Linux-based cloud hosting.
"The constraint was SSD space — not the application, not the licensing, not Linux. Once that was clear, the answer was straightforward: use an OS that fits the disk. Ubuntu with Wine delivered a working Windows web server in roughly 35 GB, retired a $270/month business internet bill, and moved the office fully into the cloud. The trade-off was 2 GB of extra RAM. It was worth it."
// tech.reference
Technology Reference
| Component | Choice | Rationale |
|---|
| Linux Distribution | Xubuntu 25.10 Minimal | Lightweight GUI; Wine requires a desktop environment. Minimal install keeps the disk footprint small. |
| Hypervisor (dev/test) | Microsoft Hyper-V | Familiar Windows tooling; used for both local VMs and staging before OVH deployment. |
| Cloud Hosting | OVH Cloud VPS | $5/month with static IP included; solved the business-internet problem entirely. |
| Windows Compatibility | Wine + Winetricks | Runs the Clarion .exe on Linux without modification, no Windows license required. |
| Web Proxy / SSL | nginx | Forwards ports 80/443 to Wine's port space (8080/8443); handles SSL TCP passthrough via stream module. |
| File Transfer | WinSCP (SSH) | Familiar Windows-side tool for uploading application files to the Linux VM. |
| Runtime Dependency | vcrun2015 (Winetricks) | Visual C++ 2015 runtime required by the Clarion application under Wine. |
| Application | Clarion + NetTalk by Capesoft | Production Windows-native web server; zero code changes required. |
