Affiliate Systems Suck, So We Rolled Our Own

Let’s be completely honest; most affiliate systems on the market are downright horrible. Either they’re confusing beyond belief, clunky and slow, or they look like they were designed back in the ’90s. Or worse, a mixture of all of the above. Some might have half of the tools you need but then are missing other essential features that your affiliate marketers want. ?

Since we launched Kinsta, it has been our mission never to release anything subpar to clients. A standard we uphold is that if it’s something we wouldn’t use ourselves, then we have to find a better way. So just as we did with our MyKinsta dashboard, we decided to build our own.

Today we’ll discuss some of the reasons we went down this route, both from a business and development perspective, as well as what we ended up with (from MVP to the final product).

Why We Rolled Our Own

When we started researching what needed to be done to implement an affiliate system, we quickly realized there was no out-of-the-box solution for us. Here are the main reasons why:

• The biggest problem was that our affiliate system needed to be tightly coupled with our plans and subscription system, not with a third-party provider.
• Branding is very important to us. While some affiliate systems offer white-label solutions, most are half-baked implementations and not always fully transparent. Building it ourselves would allow us to have full control over the design and branding, without having to even worry about white-labeling solutions.
• Relying on a third-party system would prevent us from adding new features quickly or at all. Most of our custom MyKinsta dashboard is built entirely from user feedback, and that’s why it has become one of the best WordPress site management tools in the industry! Thanks to our amazing clients. ? We knew the minute we launched with a third-party solution, feedback and requests would start flowing in, and we wouldn’t have the ability to make those happen.
• The ability to provide and build custom reporting, not only for our affiliates but also for our administrators was something we couldn’t live without. We love and need data! How else are you supposed to make strategic decisions going forward? Pulling the reporting data also had to be done from our complex plans and subscription system.

Digging into this a little more, we knew that once we opened up the affiliate system to the general public we couldn’t stop it. Sure, bugs creep in which are fixed, but if we needed to switch a payment provider, we couldn’t just put our affiliates on hold while we keep on collecting money that they would be entitled to.

Also, flexibility was a major concern. What if we had to change the internals of how subscriptions were handled (this actually ended up happening), would we be able to handle multiple languages and currencies? How about add-ons that we developed along the way like Redis, hourly backups, and so on. Could we build an expandable dashboard for our users?

From a technical point of view, it proved to be completely redundant to use someone else’s software. Since we have a particular way of handling subscriptions via Stripe, we needed to write our own logic for what a referral is and what the change-mechanism is for upgrades and downgrades.

While I’m sure many solutions have API’s, writing the code to send our data to the API would be 80% of the work. Why not put in an additional 20% and create our own UI which we are pretty adept at anyway.

Costs Involved

Another big concern was pricing. There are cheap products on the market but they didn’t make the cut due to feature or flexibility concerns. Others take care of payments well and have more features, but their merchant fees add up fast. Let’s take a look at the cost of some of the most popular ones. Note: some of these perhaps could be negotiated down a little based on the volume of sales and other factors.

• ShareASale: $550 one-time network fee, $100 deposit, and a 20% transaction fee on every sale.
• CJ: $3,000 network fee, $3,000 deposit, $500 annual access fee, and 30% transaction fee or $0.30 on every sale – whichever amount is greater.
• ClickBank: $49.95 activation charge, $2.50 pay period processing charge, and 7.5% transaction fee + $1 on every sale.

Let’s say we do $250,000 a year from affiliate sales, here’s what the fees would come out to (this is after the one-time deposits and network access fees). By the way, what are network access fees? ?

• ShareASale: $50,000 in fees
• CJ: $75,000 in fees
• ClickBank: $27,000 in fees

Yikes! That is a lot. And that is before you calculate in other fees that we’re already paying to our payment processor Stripe. We also looked at other affiliate systems such as Rakuten Marketing and Impact Radius, but the costs were even higher.

The benefit of rolling our own affiliate system is that our biggest cost would simply be development time. We already had the amazing talent in-house to build everything. But as you can see, there are a lot of moving parts and things to consider when choosing to roll your own or go with a third-party solution.

The Basics of How Our Affiliate System Works

I’ll go into details further down, but to understand how we started building the product it’s useful to know the basic flow of data.

The point of entry into the system is a special link that contains an affiliate ID. We call this the Kinsta affiliate ID or KAID for short (example: https://kinsta.com?kaid=affiliateid)

Most other affiliate tools are simply downright confusing when it comes to knowing what URL you should use and where to link to. So from the very beginning, we wanted to make it a simple two-step process.

Step 1

The first step would be to input the destination on the Kinsta website. This could be anywhere, not just our home page. Perhaps they want to link directly to our plans page (as seen below).

Step 2

The second step would be to generate the link for them so they can easily copy and paste this wherever they like. And also to provide the accompanying HTML with the rel=”sponsored” link attribute (which is very important) to comply with Google’s guidelines for affiliate links. Google previously recommended using the nofollow attribute, which is still a viable option.

When we detect a visitor using such one of these links we set a cookie that contains information about who referred the user. We value the initial referrer and don’t offer split commissions. This is fairer to the affiliate and leads to a competition of quality over quantity.

Stripe handles all purchases, we use its extensive and (mostly) well-documented API to create users, subscriptions, initiate payments, and more. The purchase flow happens on the website which in turn uses MyKinsta’s internal API to initiate the processes we need to get the user signed up. The information about who referred the customer is also recorded in our system.

The MVP (Start Building)

Whenever you launch something new it can be wise to build an MVP (minimum viable product) and start marketing right away to test the waters. Get feedback early on and learn from it. Adapt, change, and make improvements. This is exactly what we did when we first launched Kinsta, and how we’ve bootstrapped from $0 to 7-figures in revenue.

We knew from the get-go that the most challenging part of the system would be the logic that takes care of tracking and calculating commissions. Initially, the whole system was written in PHP and relied purely on Stripe to calculate everything ad-hoc.

The way we calculated commissions for a referral was to look at the whole Stripe history of the referred subscription and figure out how much one-time commission is due and how much recurring is due. Factors such as time elapsed and plan type would affect the calculation.

For example, if the WordPress referral was created two days ago, there was, of course, no one-time commission. If the WordPress referral was created four months ago we had to assign the one-time commission (which is due after two months) and two recurring commissions (due once a month following the one-time commission).

To get the total amount of commission to be paid for a month, we did the above for all referrals from a specific affiliate. This proved to be more calculation intensive than we initially thought. We kind of knew we would have to make a change, but we found a good compromise between functionality and development time.

The front-end was built using Flight PHP, a PHP micro-framework. We created some routes, put together some tables and graphs and off we went.

Changing the MVP (Adapting and Making Improvements)

After about seven months in private beta and perhaps six months of regular operation we needed to rebuild. Our original MVP just wasn’t built to scale. A change needed to be made in the way we handle subscriptions due to our new add-ons and overage systems. Until this point, a customer always had one subscription. We needed to change that and allow for multiple subscriptions per user.

Since our customers always had one and only one subscription we could safely say that any active referred subscription was equal to a referred hosting plan. In other words, subscriptions were what we considered referrals. We needed to make a complete overhaul which considers our Stripe customers to be referrals.

In addition, the sub-optimal way we calculated commissions was starting to rear its ugly head. It mostly affected our admins, but we did have 1-2 affiliates who experienced higher load times while we calculated all their commissions each time they viewed the dashboard.

To round things off, we wanted to move the whole system into the Node + React territory to make it use the same stack as MyKinsta. This would allow a lot more of our developers to come on board if needed and to start using a common design language more easily.

The Final Product

When we finished the rebuild we were left with a vastly superior system which required a lot less management, had a lot more features, automated common affiliate admin tasks, and shared the same technology stack as our main product, MyKinsta.

The Stack

The affiliate system now runs on Node on the backend and React on the front. It utilizes GraphQL for our query needs and Ant Design for the design framework.

There are actually four separate processes running at the same time:

• Affiliate Backend: This is the backend of the whole system. It is completely closed off from the external world; only internal communications can reach it. It is basically an entry point into the database, all it does is accept and answer to GraphQL queries
• Affiliate Dashboard: This is the user-facing side of the affiliate system. It consists of a bunch of React components that get their data via GraphQL queries from the backend
• Affiliate Admin: This is a special admin interface where the admins go to look at aggregate stats, manage applications and perform other tasks
• Affiliate Sync: A set of cron jobs that keeps everything in sync – we’ll get to this part soon as this is the meat and bones of the system

Improvements to Data and Calculations

In the initial version of the system, we calculated everything ad-hoc. This proved to be data-intensive, but it’s also not great because if we change something – like the amount of commission paid – it either changes everything in retrospect or we need to litter the code with date-based if statements.

The new affiliate system uses two mechanisms to make it a lot more efficient: a better way of grabbing data from Stripe and a ledger system to record events.

The events system ensures that whatever happens, stays. If a referral is due a one-time commission, we record that commission and attach it to the referral. We then mark that referral and never look at one-time commissions again. The same mechanism applies for recurring commissions. Once a period has had its recurring commission calculated and recorded, we “forget” about that period.

This means that calculations only need to be done for short periods of time and aggregations of commissions are done by simply summing some database rows.

The second component relies on cron jobs to gather data. We grab all data from Stripe every 10 minutes and save it to a local database making some modifications to make further processing easier.

For example, it takes a not inconsiderable amount of code to figure out if a subscription change event involves a hosting plan. We can calculate this ad-hoc when we need to but rather than doing that we use the cron job to add a flag to the saved object. Since we’re grabbing 10 minutes of data, the whole process takes perhaps 100 milliseconds and makes further select queries a lot more efficient.

A second cron job shuffles the data into its final place, calculating commissions, creating events, and other operations.

The reason these are done separately is that the first operation is super-simple but relies on Stripe while the second operation is considerably more intensive and complex. If we introduce a bug into the second operation which makes it fail we won’t need to resync hours/days/weeks of Stripe data; we’ll just need to re-run the second operation.

This setup provides numerous other benefits each cron job is in-turn made up of several distinct components like getting new subscriptions, approving pending commissions and so on. In the future, we may want to break down our cron jobs further to make sure we can catch issues as early as possible without affecting other parts of the system.

After optimizing our calculations and moving to a new framework our affiliate dashboard now loads twice as fast! ?

The Affiliate System and Program in Action

The post wouldn’t be complete without showing off our affiliate system and program in action. Here are just a few of the features and advantages we offer to all affiliates at Kinsta.

1. Unbeatable Commissions (Signup Bonus + Recurring)

We worked long and hard on our commission and payout structure as we realize this is probably one of the most important factors for affiliates. In fact, many bloggers and website owners we host earn their entire living from affiliate income. We are proud to now offer the highest payouts in the industry! And we offer commissions no matter the hosting services referred.

For every Kinsta WordPress hosting plan someone refers, they get a one-time signup bonus, as follows:

• Starter plan ($50)
• Pro plan ($100)
• Business 1-4 ($150)
• Enterprise 1-2 ($500)

Affiliates also get a 10% monthly recurring commission for every WordPress referral, on top of the signup bonus. And for Application Hosting and Database Hosting referrals, we also offer 5% monthly recurring commissions. But wait, we don’t stop there! The recurring commissions are cumulative, making it one of the hosting industry’s best deals.

Below are just a few of the many examples we have of how our WordPress commission payouts work. See more examples of payout scenarios in our affiliate terms.

WordPress Signup Bonus Example

WordPress Recurring Commission Example

2. Real-Time Tracking

Our affiliate dashboard is unlike any other on the market! You can view affiliate data in near real-time, page views, subscriptions, in-depth plan details, and even drill-down to individual referrals and check all payments from that one referral (as seen below).

3. High Lifetime Value

One of the greatest advantages of referring people to Kinsta is that we have an incredibly high lifetime value for each client. Our churn rate is under 2%! This means affiliates can easily earn recurring commissions for the lifetime of that customer.

4. Monthly Payouts

There is no need for affiliates to worry or mark their calendars. Kinsta always pays on time and it’s sent right to the affiliates PayPal account each month.

5. Quick Promo Materials

Need banners to promote Kinsta on a website or blog? Don’t worry, we’ve got lots of them! The promotional banners and logos can all be easily accessed right from the affiliate dashboard.

6. Long Conversion Window

People are busy and might not convert right away. A lot of times, people like to shop around when it comes time to choosing a new cloud host. That’s why we provide affiliates 60-day tracking cookies to ensure they get credited for the sale.

7. ITP 2.0 Ready

The Kinsta affiliate system is ITP 2.0 ready! Intelligent Tracking Prevention 2.0 (ITP) is a new setting from Apple in Safari 11 and above which essentially limits the access web-based tracking solutions have to cookies in the browser. According a recent study, as of October 2020, Safari still holds around 8% of web browser market share. So this change has a big impact on the advertising industry.

However, not to worry. The Kinsta affiliate system relies solely on first-party cookies without bouncing or other methods of sidestepping ITP. As a result, all referrals will be tracked and recorded appropriately as they have been before ITP 2.0.

We deliberately built the system without resorting to “ITP-proof” methods for the following reasons:

1. We believe in honest, transparent tracking, and gathering as little data as possible.
2. We don’t need to track visitors through multiple sites.
3. We anticipated the rules of the web becoming stricter with time.

You can read more about the ramifications of ITP 2.0.

8. Multilingual Dashboard – Available in Five Languages

Our Kinsta affiliate dashboard is now available in eight different languages and more are coming. Currently, you can choose the following:

• English
• German
• French
• Spanish
• Italian
• Dutch
• Portuguese
• Japanese

9. Helping Affiliates Succeed

Besides building an awesome affiliate system and dashboard, we truly want affiliates to succeed. There really is no limit on the amount of money they can make. It’s completely free for anyone to join. Sign up here.

Note: We do approve affiliate accounts manually, just to ensure sites abide by our affiliate terms.

The marketing team at Kinsta, along with our affiliate manager, are here to help. We are happy to provide affiliate marketing tips and affiliate sales tips on ways to take promotions to the next level. In fact, we are working on producing additional content on our blog designed specifically for affiliate marketers, and ways to boost earnings.

Summary

Our current implementation has proven to be a lot more stable, light years faster, and a better experience for our affiliates and admins alike. It laid down a solid foundation based on which we can build a fantastic product and program.

One great benefit is that we can now focus more on user-facing improvements. We’ve added more charts, URL tracking and more in the couple of months after release. We plan on improving the user experience even further and giving tools to our affiliates which enable them to earn more.

We’re nowhere close to being done! ?

Thinking about building your own affiliate system? We won’t lie, it’s a lot of work, but well worth the time and effort. We now have a system our entire team is proud of and affiliates enjoy using.