A lot of people are talking about the problems that are being caused by a recent change to taxation in the EU; this TechCrunch article gives a nice overview of the issues. But we thought it would be fun just to tell about our experience - for general interest, and as an example of what one UK startup had to do to implement these changes. Short version: it hasn’t been fun.
If you know all about the EU VAT changes and just want to know what we did at PythonAnywhere, click here to skip the intro. Otherwise, read on…
The background¶
“We can fight over what the taxation levels should be, but the tax system should be very, very simple and not distortionary.”
- Adam Davidson
The tax change is, in its most basic form, pretty simple. But some background will probably help. The following is simplified, but hopefully reasonably clear.
VAT is Value Added Tax, a tax that is charged on pretty much all purchases of anything inside the EU (basic needs like food are normally exempt). It’s not dissimilar to sales or consumption tax, but the rate is quite high: in most EU countries it’s something like 20%. When you buy (say) a computer, VAT is added on to the price, so a PC that the manufacturer wants EUR1,000 for might cost EUR1,200 including VAT. Prices for consumers are normally quoted with VAT included, when the seller is targetting local customers. (Companies with large numbers of international customers, like PythonAnywhere, tend to quote prices without VAT and show a note to the effect that EU customers have to pay VAT too.)
When you pay for the item, the seller takes the VAT, and they have to pay all the VAT they have collected to their local tax authority periodically. There are various controls in place to make sure this happens, that people don’t pay more or less VAT than they’ve collected, and in general it all works out pretty simply. The net effect is that stuff is more expensive in Europe because of tax, but that’s a political choice on the part of European voters (or at least their representatives).
When companies buy stuff from each other (rather than sales from companies to consumers) they pay VAT on those purchases if they’re buying from a company in their own country, but they can claim that VAT back from their local tax authorities (or offset it against VAT they’ve collected), so it’s essentially VAT-free. And when they buy from companies in other EU countries or internationally, it’s VAT-free. (The actual accounting is a little more complicated, but let’s not get into that.)
What changed¶
“Taxation without representation is tyranny.”
- James Otis
Historically, for “digital services” – a category that includes hosting services like PythonAnywhere, but also downloaded music, ebooks, and that kind of thing – the rule was that the rate of VAT that was charged was the rate that prevailed in the country where the company doing the selling was based. This made a lot of sense. Companies would just need to register as VAT-collecting businesses with their local authorities, charge a single VAT rate for EU customers (apart from sales to other VAT-registered businesses in other EU countries), and pay the VAT they collected to their local tax authority. It wasn’t trivially simple, but it was doable.
But, at least from the tax authorities’ side, there was a problem. Different EU countries have different VAT rates. Luxembourg, for example, charges 15%, while Hungary is 27%. This, of course, meant that Hungarian companies were at a competitive disadvantage to Luxembourgeoise companies.
There’s a reasonable point to be made that governments who are unhappy that their local companies are being disadvantaged by their high tax rates might want to consider whether those high tax rates are such a good idea, but (a) we’re talking about governments here, so that was obviously a non-starter, and (b) a number of large companies had a strong incentive to officially base themselves in Luxembourg, even if the bulk of their business – both their customers and their operations – was in higher-VAT jurisdictions.
So, a decision was made that instead of basing the VAT rate for intra-EU transactions for digital services on the VAT rate for the seller, it should be based on the VAT rate for the buyer. The VAT would then be sent to the customer’s country’s tax authority – though to keep things simple, each country’s tax authority would set up a process where the company’s local tax authority would collect all of the money from the company along with a file saying how much was meant to go to each other country, and they’d handle the distribution. (This latter thing is called, in a wonderful piece of bureaucratese, a “Mini One-Stop Shop” or MOSS, which is why “VATMOSS” has been turned into a term for the whole change.)
As these kind of things go, it wasn’t too crazy a decision. But the knock-on effects, both those inherent in the idea of companies having to charge different tax rates for different people, but also those caused by the particular way the details of laws have been worked out, have been huge. What follows is what we had to change for PythonAnywhere. Let’s start with the basics.
Different country, different VAT rate¶
“The wisdom of man never yet contrived a system of taxation that would operate with perfect equality.”
- Andrew Jackson
Previously we had some logic that worked out if a customer was “vattable”. A user in the UK, where we’re based, is vattable, as is a non-business anywhere else in the EU. EU-based businesses and anyone from outside the EU were non-vattable. If a user was vattable, we charged them 20%, a number that we’d quite sensibly put into a constant called VAT_RATE
in our accounting system.
What needed to change? Obviously, we have a country for each paying customer, from their credit card/PayPal details, so a first approximation of the system was simple. We created a new database table, keyed on the country, with VAT rates for each. Now, all the code that previously used the VAT_RATE
constant could do a lookup into that table instead.
So now we’re billing people the right amount. We also need to store the VAT rate on every invoice we generate so that we can produce the report to send to the MOSS, but there’s nothing too tricky about that.
Simple, right? Not quite. Let’s put aside that there’s no solid source for VAT rates across the EU (the UK tax authorities recommend that people look at a PDF on an EU website that’s updated irregularly and has a table of VAT rates using non-ISO country identifiers, with the countries’ names in English but sorted by their name in their own language, so Austria is written “Austria” but sorted under “O” for “Österreich”).
No, the first problem is in dealing with evidence.
Where are you from?¶
“Extraordinary claims require extraordinary evidence.”
- Carl Sagan
How do you know which country someone is from? You’d think that for a paying customer, it would be pretty simple. Like we said a moment ago, they’ve provided a credit card number and an address, or a PayPal billing address, so you have a country for them. But for dealing with the tax authorities, that’s just not enough. Perhaps they feared that half the population of the EU would be flocking to Luxembourgeoise banks for credit cards based there to save a few euros on their downloads.
What the official UK tax authority guidelines say regarding determining someone’s location is this (and it’s worth quoting in all its bureaucratic glory):
1.5 Record keeping
If the presumptions referred above don’t apply, you’ll be expected to obtain and to keep in your records 2 pieces of non-contradictory evidence from the following list to support your taxing decisions. Examples include:
- the billing address of the customer
- the Internet Protocol (IP) address of the device used by the customer
- location of the bank
- the country code of SIM card used by the customer
- the location of the customer’s fixed land line through which the service is supplied to him
- other commercially relevant information (for example, product coding information which electronically links the sale to a particular jurisdiction)
Once you have 2 pieces of non-contradictory evidence that is all you need and you don’t need to collect any further supporting evidence. This is the case even if, for example, you obtain a third piece of evidence which happens to contradict the other 2 pieces of information. You must keep VAT MOSS records for a period of 10 years from 31 December of the year during which the transaction was carried out.
For an online service paid with credit cards, like PythonAnywhere, the only “pieces of evidence” we can reasonably collect are your billing address and your IP address.
So, our nice simple checkout process had to grow another wart. When someone signs up, we have to look at their IP address. We then compare this with a GeoIP database to get a country. When we have both that and their billing address, we have to check them:
- If neither the billing address nor the IP address is in the EU, we’re fine – continue as normal.
- If either the billing address or the IP address is in the EU, then:
- If they match, we’re OK.
- If they don’t match, we cannot set up the subscription. There is quite literally nothing we can do, because we don’t know enough about the customer to work out how much VAT to charge them.
We’ve set things up so that when someone is blocked due to a location mismatch like that, we show the user an apologetic page, and the PythonAnywhere staff get an email so that we can talk to the customer and try to work something out. But this is a crazy situation:
- If you’re a British developer with a UK credit card, currently on a business trip to Germany, then you can’t sign up for PythonAnywhere. This does little good for the free movement of goods and services across the EU.
- If you’re an American visiting the UK and want to sign up for our service, you’re equally out of luck. This doesn’t help the EU’s trade balance much.
- If you’re an Italian developer who’s moved to Portugal, you can’t sign up for PythonAnywhere until you have a new Portuguese credit card. This makes movement of people within the EU harder.
As far as we can tell there’s no other way to implement the rules in a manner consistent with the guidelines. This sucks.
And it’s not all. Now we need to deal with change…
Ch-ch-changes¶
“Time changes everything except something within us which is always surprised by change.”
- Thomas Hardy
VAT rates change (normally upwards). When you’re only dealing with one country’s VAT rate, this is pretty rare; maybe once every few years, so as long as you’ve put it in a constant somewhere and you’re willing to update your system when it changes, you’re fine. But if you’re dealing with 28 countries, it becomes something you need to plan for happening pretty frequently, and it has to be stored in data somewhere.
So, we added an extra valid_from
field to our table of VAT rates. Now, when we look up the VAT rate, we plug today’s date into the query to make sure that we’ve got the right VAT rate for this country today. (If you’re wondering why we didn’t just set things up with a simple country-rate mapping that would be updated at the precise point when the VAT rate changed, read on.)
No big deal, right? Well, perhaps not, but it’s all extra work. And of course we now need to check a PDF on display in the bottom of a locked filing cabinet stuck in a disused lavatory with a sign on the door saying “Beware of the Leopard” to see when it changes. We’re hoping a solid API for this will crop up somewhere – though there are obviously regulatory issues there, because we’re responsible for making sure we use the right rate, and we can’t push that responsibility off to someone else. The API would need to be provided by someone we were 100% sure would keep it updated at least as well as we would ourselves – so, for example, a volunteer-led project would be unlikely to be enough.
So what went wrong next? Let’s talk about subscription payments.
Reconciling ourselves to PayPal¶
“Nothing changes like changes, because nothing changes but the changes.”
- Gary Busey
Like many subscription services, at PythonAnywhere we use external companies to manage our billing. The awesome Stripe handle our credit card payments, and we also support PayPal. This means that we don’t need to store credit card details in our own databases (a regulatory nightmare) or do any of the horrible integration work with legacy credit card processing systems.
So, when you sign up for a paid PythonAnywhere account, we set up a subscription on either Stripe or PayPal. The subscription is for a specific amount to be billed each month; on Stripe it’s a “gross amount” (that is, including tax) while PayPal split it out into separate “net amount” and a “tax amount”. But the common thing between them is that they don’t do any tax calculations themselves. As international companies having to deal with billing all over the world, this makes sense, especially given that historically, say, a UK company might have been billing through their Luxembourg subsidiary to get the lower VAT rate, so there’s no safe assumptions that the billing companies could make on their customers’ behalf.
Now, the per-country date-based VAT rate lookup into the database table that we’d done earlier meant that when a customer signed up, we’d set up a subscription on PayPal/Stripe with the right VAT amount for the time when the subscription was created. But if and when the VAT rate changed in the future, it would be wrong. Our code would make sure that we were sending out billing reminders for the right amount, but it wouldn’t fix the subscriptions on PayPal or Stripe.
What all that means is that when a VAT rate is going to change, we need to go through all of our customers in the affected country, identify if they were using PayPal or Stripe, then tell the relevant payment processor that the amount we’re charging them needs to change.
This is tricky enough as it is. What makes it even worse is an oddity with PayPal billing. You cannot update the billing amount for a customer in the 72 hours before a payment is due to be made. So, for example, let’s imagine that the VAT rate for Malta is going to change from 18% to 20% on 1 May. At least three days before, you need to go through and update the billing amounts on subscriptions for all Maltese customers whose next billing date is after 1 May. And then sometime after you have to go through all of the other Maltese customers and update them too.
Keeping all of this straight is a nightmare, especially when you factor in things like the fact that (again due to PayPal) we actually charge people one day after their billing date, and users can be “delinquent” – that is, their billing date was several days ago but due to (for example) a credit card problem we’ve not been able to charge them yet (but we expect to be able to do so soon). And so on.
The solution we came up with was to write a reconciliation script. Instead of having to remember “OK, so Malta’s going from 18% to 20% on 1 May so we need to run script A four days before, then update the VAT rate table at midnight on 1 May, then run script B four days after”, and then repeat that across all 28 countries forever, we wanted something that would run regularly and would just make everything work, by checking when people are next going to be billed and what the VAT rate is on that date, then checking what PayPal and Stripe plan to bill them, and adjusting them if appropriate.
A code sample is worth a thousand words, so here’s the algorithm we use for that. It’s run once for every EU user (whose subscription details are in the subscription
parameter). The get_next_charge_date_and_gross_amount
and update_vat_amount
are functions passed in as a dependency injection so that we can use the same algorithm for both PayPal and Stripe.
def reconcile_subscription(
subscription,
get_next_charge_date_and_gross_amount,
update_vat_amount
):
next_invoice_date = subscription.user.get_profile().next_invoice_date()
next_charge_date, next_charge_gross_amount = get_next_charge_date_and_gross_amount(subscription)
if next_invoice_date < datetime.now():
# Cancelled subscription
return
if next_charge_date < next_invoice_date:
# We're between invoicing and billing -- don't try to do anything
return
expected_next_invoice_vat_rate = subscription.user.get_profile().billing_vat_rate_as_of(next_invoice_date)
expected_next_charge_vat_amount = subscription.user.get_profile().billing_net_amount * expected_next_invoice_vat_rate
if next_charge_gross_amount == expected_next_charge_vat_amount + subscription.user.get_profile().billing_net_amount:
# User has correct billing set up on payment processor
return
# Needs an update
update_vat_amount(subscription, expected_next_charge_vat_amount)
We’re pretty sure this works. It’s passed every test we’ve thrown at it. And for the next few days we’ll be running it in our live environment in “nerfed” mode, where it will just print out what it’s going to do rather than actually updating anything on PayPal or Stripe. Then we’ll run it manually for the first few weeks, before finally scheduling it as a cron job to run once a day. And then we’ll hopefully be in a situation where when we hear about a VAT rate change we just need to update our database with a new row with the appropriate country, valid from date, and rate, and it will All Just Work.
(An aside: this probably all comes off as a bit of a whine against PayPal. And it is. But they do have positive aspects too. Lots of customers prefer to have their PythonAnywhere accounts billed via PayPal for the extra level of control it gives them – about 50% of new subscriptions we get use it. And the chargeback model for fraudulent use under PayPal is much better – even Stripe can’t isolate you from the crazy-high chargeback fees that banks impose on companies when a cardholder claims that a charge was fraudulent.)
In conclusion¶
“You can’t have a rigid view that all new taxes are evil.”
- Bill Gates
The changes in the EU VAT legislation came from the not-completely-unreasonable attempt by the various governments to stop companies from setting up businesses in low-VAT countries for the sole purpose of offering lower prices to their customers, despite having their operations on higher-VAT countries.
But the administrative load placed on small companies (including but not limited to tech startups) is large, it makes billing systems complex and fragile, and it imposes restrictions on sales that are likely to reduce trade. We’ve seen various government-sourced estimates of the cost of these regulations on businesses floating around, and they all seem incredibly low.
At PythonAnywhere we have a group of talented coders, and it still took over a week out of our development which we could have spent working on stuff our customers wanted. Other startups will be in the same position; it’s an irritation but not the end of the world.
For small businesses without deep tech talent, we dread to think what will happen.