How Salieno Core's Billing Engine Handles Prorated Charges and Mid-Cycle Changes

Why billing logic is the invisible backbone of a hosting business#

Your customers don't think about billing until something goes wrong. An unexpected charge after a mid-month upgrade. A confusing credit on a cancellation. A renewal that doesn't match the original price. These friction points erode trust fast — and they're often not bugs, just poorly designed billing logic.

At Salieno Core, the billing engine isn't an afterthought bolted onto provisioning. It's tightly coupled with the service lifecycle, and that coupling matters most in the messy middle: when a customer upgrades their plan on day 12 of a 30-day cycle, or when a yearly subscription gets cancelled after six months.

This article walks through how Salieno Core handles prorated charges, mid-cycle changes, and credit generation — and why we made the design decisions we did.

The core problem: billing cycles and service changes rarely align#

Most hosting customers sign up on day one and stay on the same plan until they leave. But a meaningful percentage — especially among the agency and developer clients that resellers attract — will upgrade, downgrade, add resources, or cancel mid-cycle.

The naive approach is to charge the full new price immediately and reset the billing date. This creates confusion: the customer just paid three days ago, and now they're paying again? Worse, it generates pro-rata refund obligations that are painful to track.

The opposite extreme — waiting until the next renewal to apply changes — is equally problematic. A customer on a 512 MB plan who needs 4 GB today doesn't want to wait 27 days.

Salieno Core resolves this with a prorated charge model that applies changes immediately while keeping the original billing anniversary intact.

How prorated charges work in Salieno Core#

When a customer upgrades mid-cycle, the billing engine calculates the difference between their current plan and the new plan, then prorates that difference to the remaining days in the current billing period.

Here's a concrete example:

• Current plan: Starter Hosting at $10/month
• Upgrade to: Business Hosting at $25/month
• Days elapsed: 10 of 30
• Remaining days: 20

The prorated charge is: ($25 - $10) × (20 ÷ 30) = $10.00

That $10 charge is generated as a separate line item on a new invoice, due immediately. The customer's next regular renewal — 20 days later — will be at the new $25 rate.

The original billing date never moves. This is a deliberate choice. Billing date stability makes revenue forecasting simpler for resellers, and it avoids the cascade of edge cases that billing-date resets create (what happens to annual plans? what about leap months? what if the customer downgrades and upgrades in the same cycle?).

Downgrades and credit generation#

Downgrades are the mirror image, but with a twist: instead of charging the customer, you owe them a credit.

Salieno Core handles this by generating a credit note for the prorated difference. Using the same math:

• Current plan: Business Hosting at $25/month
• Downgrade to: Starter Hosting at $10/month
• Days elapsed: 10 of 30
• Remaining days: 20

Credit generated: ($25 - $10) × (20 ÷ 30) = $10.00 credit

That credit sits on the customer's account and automatically applies to their next invoice. If the next invoice is the $10 renewal, the customer pays $0. If they cancel before the next renewal, the credit is visible in the admin panel and can be refunded manually at the reseller's discretion.

We chose automatic credit application over automatic refunds because it keeps the customer in your ecosystem. A credit on file is a reason to stay. A refund is a goodbye.

Mid-cycle resource add-ons#

Plan changes are one thing, but many resellers sell add-on resources — extra disk space, additional domains, SSL certificates, dedicated IPs. These often have their own billing cadences.

Salieno Core treats add-ons as independent line items with their own billing anniversaries. If a customer adds a $3/month SSL certificate on the 15th of the month, that SSL has its own renewal date on the 15th. It doesn't merge into the hosting plan's invoice.

This keeps things auditable. When a customer asks "why was I charged $3 on the 15th?" the answer is clean and traceable. It also means removing an add-on mid-cycle generates its own small prorated credit, independent of the hosting plan's billing.

The trade-off is that customers with multiple add-ons may see multiple invoices per month. For resellers who prefer a single consolidated invoice, Salieno Core's invoice grouping setting lets you batch all charges due within a configurable window (default: 3 days) into one invoice.

Cancellations and the final invoice#

When a customer cancels, the question is: do you refund the unused portion of their current billing period?

This is ultimately a business decision, not a software one. Salieno Core supports three cancellation modes that resellers can configure per product group:

• Immediate termination, no refund. Service stops now, no credit. Simple and common for low-cost shared hosting.
• Immediate termination, prorated credit. Service stops now, a credit note is generated for unused days. The credit can be applied to other services or flagged for manual refund.
• End-of-period termination. Service continues until the current billing period expires, then stops. No refund needed.

The middle option is the most customer-friendly, and it's what we recommend for resellers competing on service quality rather than rock-bottom pricing. It signals fairness and reduces chargeback risk.

Edge cases we deliberately don't handle automatically#

Honesty requires acknowledging limits. There are scenarios where automatic billing logic breaks down:

• Coupons and promotional pricing. If a customer is on a 50%-off-for-life promo and upgrades, should the prorated charge reflect the promo price or the full price? Salieno Core applies the promo discount to the prorated charge, but this can produce surprising small amounts. Resellers should review promo-eligible upgrade flows.
• Currency changes mid-cycle. We don't support changing a customer's billing currency after signup. The FX edge cases are too dangerous.
• Retroactive plan changes. If a reseller manually adjusts a service to a different plan and backdates it, the prorated engine doesn't recalculate historical invoices. It generates a credit or charge based on the effective date of the change.

Why this matters for your business#

Clean billing logic isn't glamorous, but it's the difference between a hosting business that scales and one that drowns in support tickets about mysterious charges. Every "what is this $2.37 charge?" ticket costs you five minutes and a tiny piece of customer trust.

Prorated billing with stable billing dates is the industry standard for a reason — it's what customers expect from SaaS, and hosting is no different. If your current setup requires manual invoice adjustments every time someone upgrades, that's a scaling bottleneck you'll feel at 200 customers, not 2,000.

The billing engine is one of those components where getting the details right compounds over time. Happy customers don't open billing tickets. They just renew.