So, 34M kg of fuel has to be burned (in this booster alone) to facilitate a flight ... and I see that the propellant is CH4 / LOX[1].
Burning methane is much, much better than simply releasing methane but the release becomes CO2 instead ...
What is the back-of-the-envelope conversion of 34M kg CH4 vs., for instance, 34M kg of kerosene/JP ?
[1] https://en.wikipedia.org/wiki/SpaceX_Super_Heavy#Engines
[1] https://www.engineeringtoolbox.com/co2-emission-fuels-d_1085... [2] https://x.com/elonmusk/status/1298426245991063554?lang=en
Anyways here's the example MAD folding picture from the exhibit when its folded -- https://www.google.com/url?sa=i&url=https%3A%2F%2Fbtwberkshi...
Working link to the page that contains the picture: https://btwberkshires.com/arts/visual-arts/mad-magazine-draw...
I was just coming to hn this morning because I wrote about using FF for entitlements: https://prefab.cloud/blog/modeling-product-entitlements-with... I took some inspiration from another of Arnon's posts about SKU format for the post.
FF don't seem like the perfect place for entitlements, but in my experience they're often the best tool at hand to deal with the challenges. I'd love to hear alternative opinions.
That's why we decided to offer separate feature entitlements that are tightly coupled to the billing chain and metering as part of Wingback (disclaimer: I'm the CTO). In the end, depending on your plan complexity and how much you have already invested in feature flags, I think both approaches can work well. Having some kind of feature gating in place for your customers will also make your life a lot easier for provisioning customer accounts and being able to offer custom packages.
However, I will admit, I had a hearty chuckle at this line:
> "why can’t we just dump a file of what we need to bill on S3, and have a CRON job pick it up and collect payment?"
Under no circumstances does my engineer brain think this is a good idea. At all.
But, I will dump one aspect of my engineer-brain thoughts: My favorite "billing architecture" decision is to try to decouple billing as much as possible from credit in a system. For example, if you have a subscription system where the user pays ahead for a given billing period, I prefer to have the entitlement itself just store the expiration date and the details about what entitlements the subscription grants during the time period it is active. The billing system can store the subscription and sync back to the entitlement as-needed. This makes both manual billing by human operators (not to mention debugging and patching around momentary issues) and something like a Stripe integration very easy. You should, of course, be very careful to leave it open for extension in the future, but this seems to be a very nice decision that doesn't, in itself, limit you too much.
Obviously, this is not my original idea, but it's still something I've grown to like a lot, especially after having tried other things less successfully.
I think a lot of the issues arise from the difference between payments and billing [0]. When just starting out and signing up your first customers, you primarily care about collecting a few (recurring) payments - and it's really easy to set that up with Stripe (or even just manually invoicing your first customers).
However, over time, more billing requirements gradually sneak in, such as more complex entitlements, multiple plans, grandfathering, and eventually enterprise/high touch sales customers (where the money is!) who need custom billing cycles, terms, and entitlement provisioning. Since billing is never a technical focus, numerous additions and small hacks accumulate over time, taking engineering resources away from the actual product. Eventually, this turns into an unmanageable mess that can significantly slow down the sales process or limit what you can sell.
The complexity of billing is riddled with hidden pitfalls and edge cases, and it has become even more complex now that most plans include many different limits and usage-based components and that most SaaS companies sell globally. Many later-stage companies have teams of 15+ engineers working solely on billing. I fully agree with the author that, unless it's at the core of your product, no organization should build a billing system themselves (Disclaimer: I'm the CTO of Wingback, a SaaS Billing Platform).
[0] https://www.wingback.com/blog/saas-payment-vs-saas-billing
Really easy to set up too, just make sure to also set up DKIM/SPF/DMARC to make sure the forwarded emails don't go to spam.
[1] https://www.engineeringtoolbox.com/co2-emission-fuels-d_1085... [2] https://x.com/elonmusk/status/1298426245991063554?lang=en