diff --git a/uncloud_pay/management/commands/import-vat-rates.py b/uncloud_pay/management/commands/import-vat-rates.py
index 32938e4..2eaf80b 100644
--- a/uncloud_pay/management/commands/import-vat-rates.py
+++ b/uncloud_pay/management/commands/import-vat-rates.py
@@ -20,8 +20,8 @@ class Command(BaseCommand):
                         if line_count == 0:
                             line_count += 1
                         obj, created = VATRate.objects.get_or_create(
-                            start_date=row["start_date"],
-                            stop_date=row["stop_date"] if row["stop_date"] is not "" else None,
+                            starting_date=row["start_date"],
+                            ending_date=row["stop_date"] if row["stop_date"] is not "" else None,
                             territory_codes=row["territory_codes"],
                             currency_code=row["currency_code"],
                             rate=row["rate"],
diff --git a/uncloud_pay/models.py b/uncloud_pay/models.py
index 15613a7..36057d3 100644
--- a/uncloud_pay/models.py
+++ b/uncloud_pay/models.py
@@ -18,7 +18,6 @@ from calendar import monthrange
 from decimal import Decimal
 
 import uncloud_pay.stripe
-from uncloud_pay.helpers import beginning_of_month, end_of_month
 from uncloud_pay import AMOUNT_DECIMALS, AMOUNT_MAX_DIGITS, COUNTRIES
 from uncloud.models import UncloudModel, UncloudStatus
 
@@ -64,12 +63,9 @@ def start_after(a_date):
 def default_payment_delay():
     return timezone.now() + BILL_PAYMENT_DELAY
 
-
 class Currency(models.TextChoices):
     """
-    We don't support months are years, because they vary in length.
-    This is not only complicated, but also unfair to the user, as the user pays the same
-    amount for different durations.
+    Possible currencies to be billed
     """
     CHF   = 'CHF', _('Swiss Franc')
     EUR   = 'EUR', _('Euro')
@@ -97,12 +93,32 @@ def get_balance_for_user(user):
             0)
     return payments - bills
 
+###
+# Stripe
+
 class StripeCustomer(models.Model):
     owner = models.OneToOneField( get_user_model(),
             primary_key=True,
             on_delete=models.CASCADE)
     stripe_id = models.CharField(max_length=32)
 
+###
+# Hosting company configuration
+
+class HostingProvider(models.Model):
+    """
+    A class resembling who is running this uncloud instance.
+    This might change over time so we allow starting/ending dates
+
+    This also defines the taxation rules
+
+    WIP.
+    """
+    starting_date = models.DateField()
+    ending_date = models.DateField()
+
+
+
 ###
 # Payments and Payment Methods.
 
@@ -393,6 +409,55 @@ class Product(UncloudModel):
                                                            'one_time_price_per_unit': 0,
                                                            'recurring_price_per_unit': 15/1000
                                                           },
+                                                         'additional_ipv4_address':
+                                                         { 'min': 0,
+                                                           'one_time_price_per_unit': 0,
+                                                           'recurring_price_per_unit': 8
+                                                          },
+                                                     }
+                                                 }
+                                                 )
+
+        obj.recurring_periods.add(recurring_period, through_defaults= { 'is_default': True })
+
+        obj, created = cls.objects.get_or_create(name="Dual Stack Virtual Machine v2",
+                                                 description="A standard virtual machine",
+                                                 currency=Currency.CHF,
+                                                 config={
+                                                     'features': {
+                                                         'base':
+                                                         { 'min': 1,
+                                                           'max': 1,
+                                                           'one_time_price_per_unit': 0,
+                                                           'recurring_price_per_unit': 1
+                                                          },
+                                                         'cores':
+                                                         { 'min': 1,
+                                                           'max': 48,
+                                                           'one_time_price_per_unit': 0,
+                                                           'recurring_price_per_unit': 3
+                                                          },
+                                                         'ram_gb':
+                                                         { 'min': 1,
+                                                           'max': 256,
+                                                           'one_time_price_per_unit': 0,
+                                                           'recurring_price_per_unit': 4
+                                                          },
+                                                         'ssd_gb':
+                                                         { 'min': 10,
+                                                           'one_time_price_per_unit': 0,
+                                                           'recurring_price_per_unit': 0.35
+                                                          },
+                                                         'hdd_gb':
+                                                         { 'min': 0,
+                                                           'one_time_price_per_unit': 0,
+                                                           'recurring_price_per_unit': 15/1000
+                                                          },
+                                                         'additional_ipv4_address':
+                                                         { 'min': 0,
+                                                           'one_time_price_per_unit': 0,
+                                                           'recurring_price_per_unit': 9
+                                                          },
                                                      }
                                                  }
                                                  )
@@ -544,6 +609,8 @@ class Product(UncloudModel):
 
         """
 
+        # FIXME: This logic needs to be phased out / replaced by product specific (?)
+        # proportions. Maybe using the RecurringPeriod table to link the possible discounts/add ups
 
         if self.default_recurring_period == RecurringPeriod.PER_365D:
             if requested_period == RecurringPeriod.PER_365D:
@@ -669,21 +736,26 @@ class Order(models.Model):
 
         return self.starting_date + datetime.timedelta(seconds=self.recurring_period.duration_seconds)
 
-    @property
-    def next_cancel_or_downgrade_date(self):
+
+    def next_cancel_or_downgrade_date(self, until_when=None):
         """
         Return the next proper ending date after n times the
         recurring_period, where n is an integer that applies for downgrading
         or cancelling.
         """
 
-        if self.recurring_period.seconds > 0:
-            now = timezone.now()
-            delta = now - self.starting_date
+        if not until_when:
+            until_when = timezone.now()
 
-            num_times = ceil(delta.total_seconds() / self.recurring_period)
+        if until_when < self.starting_date:
+            raise ValidationError("Cannot end before start of start of order")
 
-            next_date = self.starting_date + datetime.timedelta(seconds= num_times * self.recurring_period)
+        if self.recurring_period.duration_seconds > 0:
+            delta = until_when - self.starting_date
+
+            num_times = ceil(delta.total_seconds() / self.recurring_period.duration_seconds)
+
+            next_date = self.starting_date + datetime.timedelta(seconds=num_times * self.recurring_period.duration_seconds)
         else:
             next_date = self.starting_date
 
@@ -694,12 +766,13 @@ class Order(models.Model):
         Determine the ending date given a specific bill
         """
 
-        # If the order is quit, charge the final amount (?)
+        # If the order is quit, charge the final amount / finish (????)
+        # Probably not a good idea -- FIXME :continue until usual
         if self.ending_date:
             this_ending_date = self.ending_date
         else:
-            if self.earliest_ending_date > bill.ending_date:
-                this_ending_date = self.earliest_ending_date
+            if self.next_cancel_or_downgrade_date(bill.ending_date) > bill.ending_date:
+                this_ending_date = self.next_cancel_or_downgrade_date(bill.ending_date)
             else:
                 this_ending_date = bill.ending_date
 
@@ -796,6 +869,7 @@ class Order(models.Model):
     def create_bill_record(self, bill):
         br = None
 
+        # Note: check for != 0 not > 0, as we allow discounts to be expressed with < 0
         if self.one_time_price != 0 and self.billrecord_set.count() == 0:
             br = BillRecord.objects.create(bill=bill,
                                            order=self,
@@ -808,7 +882,6 @@ class Order(models.Model):
 
             if br:
                 self.update_bill_record_for_recurring_order(br, bill)
-
             else:
                 br = self.create_new_bill_record_for_recurring_order(bill)
 
@@ -948,7 +1021,9 @@ class Bill(models.Model):
                                         on_delete=models.CASCADE,
                                         editable=True,
                                         null=False)
+
     # FIXME: editable=True -> is in the admin, but also editable in DRF
+    # Maybe filter fields in the serializer?
 
     is_final = models.BooleanField(default=False)
 
@@ -960,9 +1035,6 @@ class Bill(models.Model):
                                     name='one_bill_per_month_per_user')
         ]
 
-    def __str__(self):
-        return f"Bill {self.owner}-{self.id}"
-
     def close(self):
         """
         Close/finish a bill
@@ -1001,7 +1073,6 @@ class Bill(models.Model):
 
     @classmethod
     def create_next_bill_for_user_address(cls, billing_address, ending_date=None):
-
         """
         Create the next bill for a specific billing address of a user
         """
@@ -1021,6 +1092,12 @@ class Bill(models.Model):
 
     @classmethod
     def get_or_create_bill(cls, billing_address, ending_date=None):
+        """
+        Get / reuse last bill if it is not yet closed
+
+        Create bill, if there is no bill or if bill is closed.
+        """
+
         last_bill = cls.objects.filter(billing_address=billing_address).order_by('id').last()
 
         all_orders = Order.objects.filter(billing_address=billing_address).order_by('id')
@@ -1056,163 +1133,8 @@ class Bill(models.Model):
 
         return bill
 
-    # @classmethod
-    # def create_bill_records_for_recurring_orders(cls, bill):
-    #     """
-    #     Create or update bill records for recurring orders for the
-    #     given bill
-    #     """
-
-    #     owner = bill.owner
-    #     billing_address = bill.billing_address
-
-    #     all_orders = Order.objects.filter(owner=owner,
-    #                                       billing_address=billing_address).order_by('id').exclude(recurring_period=RecurringPeriod.ONE_TIME)
-
-    #     for order in all_orders:
-    #         bill_record_for_this_bill = BillRecord.objects.filter(bill=bill,
-    #                                                               order=order).first()
-    #         if bill_record_for_this_bill:
-    #             cls.update_bill_record_for_this_bill(bill_record_for_this_bill,
-    #                                                  order,
-    #                                                  bill)
-
-    #         else:
-    #             cls.create_new_bill_record_for_this_bill(order, bill)
-
-
-    @classmethod
-    def create_next_bill_for_user_address_old(cls,
-                                          owner,
-                                          billing_address,
-                                          ending_date=None):
-        """
-            Filtering ideas (TBD):
-            If order is replaced, it should not be added anymore if it has been billed "last time"
-            If order has ended and finally charged, do not charge anymore
-
-           Find out the last billrecord for the order, if there is none, bill from the starting date
-        """
-
-        last_bill = cls.objects.filter(owner=owner, billing_address=billing_address).order_by('id').last()
-
-        # it is important to sort orders here, as bill records will be
-        # created (and listed) in this order
-        all_orders = Order.objects.filter(owner=owner,
-                                          billing_address=billing_address).order_by('id')
-        first_order = all_orders.first()
-
-        bill = None
-        ending_date = None
-
-        # Get date & bill from previous bill, if it exists
-        if last_bill:
-            if not last_bill.is_final:
-                bill = last_bill
-                starting_date = last_bill.starting_date
-
-                # FIXME: take given (parameter) or existing ending_date?
-                ending_date = bill.ending_date
-            else:
-                starting_date = last_bill.ending_date + datetime.timedelta(seconds=1)
-        else:
-            if first_order:
-                starting_date = first_order.starting_date
-            else:
-                starting_date = timezone.now()
-
-        if not ending_date:
-            ending_date = end_of_month(starting_date)
-
-        if not bill:
-            bill = cls.objects.create(
-                owner=owner,
-                starting_date=starting_date,
-                ending_date=ending_date,
-                billing_address=billing_address)
-
-        for order in all_orders:
-            if order.is_one_time:
-                # this code should be ok, but needs to be double checked
-                if order.billrecord_set.count() == 0:
-                    br = BillRecord.objects.create(bill=bill,
-                                                   order=order,
-                                                   starting_date=order.starting_date,
-                                                   ending_date=order.ending_date)
-
-            else: # recurring orders
-                bill_record_for_this_bill = BillRecord.objects.filter(bill=bill,
-                                                                      order=order).first()
-
-                # This bill already has a bill record for the order
-                # We potentially need to update the ending_date if the ending_date
-                # of the bill changed.
-                if bill_record_for_this_bill:
-                    # we may need to adjust it, but let's do this logic another time
-
-                    # If the order has an ending date set, we might need to adjust the bill_record
-                    if order.ending_date:
-                        if bill_record_for_this_bill.ending_date != order.ending_date:
-                            bill_record_for_this_bill.ending_date = order.ending_date
-
-                    else:
-                        # recurring, not terminated, should go until at least end of bill
-                        if bill_record_for_this_bill.ending_date < bill.ending_date:
-                            bill_record_for_this_bill.ending_date = bill.ending_date
-
-
-                    bill_record_for_this_bill.save()
-
-                else: # No bill record in this bill for this order yet
-                    # Find out when billed last time
-                    last_bill_record = BillRecord.objects.filter(order=order).order_by('id').last()
-
-                    # Default starting date
-                    this_starting_date=order.starting_date
-
-                    # Skip billing again, if we have been processed for this bill duration
-                    if last_bill_record:
-                        if last_bill_record.ending_date >= bill.ending_date:
-                            continue
-
-                        # If the order ended and has been fully billed - do not process it
-                        # anymore
-                        if order.ending_date:
-                            if last_bill_record.ending_date == order.ending_date:
-                                # FIXME: maybe mark order for not processing anymore?
-                                # I imagina a boolean column, once this code is stable and
-                                # verified
-                                continue
-
-                            # Catch programming bugs if the last bill_record was
-                            # created incorrectly - should never be entered!
-                            if order.ending_date < last_bill_record.ending_date:
-                                raise ValidationError(f"Order {order.id} ends before last bill record {last_bill_record.id}")
-
-                        # Start right after last billing run
-                        this_starting_date = last_bill_record.ending_date + datetime.timedelta(seconds=1)
-
-
-                    # If the order is already terminated, use that date instead of bill date
-                    if order.ending_date:
-                        this_ending_date = order.ending_date
-                    else:
-                        if order.earliest_ending_date > bill.ending_date:
-                            this_ending_date = order.earliest_ending_date
-                        else:
-                            # bill at maximum for this billing period
-                            this_ending_date = bill.ending_date
-
-                    # And finally create a new billrecord!
-                    br = BillRecord.objects.create(bill=bill,
-                                                   order=order,
-                                                   starting_date=this_starting_date,
-                                                   ending_date=this_ending_date)
-
-
-
-
-        return bill
+    def __str__(self):
+        return f"Bill {self.owner}-{self.id}"
 
 
 class BillRecord(models.Model):
@@ -1261,10 +1183,10 @@ class BillRecord(models.Model):
         super().save(*args, **kwargs)
 
 
-
 class ProductToRecurringPeriod(models.Model):
     """
-    Intermediate manytomany mapping class
+    Intermediate manytomany mapping class that allows storing the default recurring period
+    for a product
     """
 
     recurring_period = models.ForeignKey(RecurringPeriod, on_delete=models.CASCADE)
@@ -1283,52 +1205,3 @@ class ProductToRecurringPeriod(models.Model):
 
     def __str__(self):
         return f"{self.product} - {self.recurring_period} (default: {self.is_default})"
-
-
-# # Sample products included into uncloud
-# class SampleOneTimeProduct(models.Model):
-#     """
-#     Products are usually more complex, but this product shows how easy
-#     it can be to create your own one time product.
-#     """
-
-#     default_recurring_period = RecurringPeriod.ONE_TIME
-
-#     ot_price = models.IntegerField(default=5)
-
-#     @property
-#     def one_time_price(self):
-#         return self.ot_price
-
-# class SampleRecurringProduct(models.Model):
-#     """
-#     Products are usually more complex, but this product shows how easy
-#     it can be to create your own recurring fee product.
-#     """
-
-#     default_recurring_period = RecurringPeriod.PER_30D
-
-#     rc_price = models.IntegerField(default=10)
-
-#     @property
-#     def recurring_price(self):
-#         return self.rc_price
-
-# class SampleRecurringProductOneTimeFee(models.Model):
-#     """
-#     Products are usually more complex, but this product shows how easy
-#     it can be to create your own one time + recurring fee product.
-#     """
-
-#     default_recurring_period = RecurringPeriod.PER_30D
-
-#     ot_price = models.IntegerField(default=5)
-#     rc_price = models.IntegerField(default=10)
-
-#     @property
-#     def one_time_price(self):
-#         return self.ot_price
-
-#     @property
-#     def recurring_price(self):
-#         return self.rc_price