Forem: Salable

Monetise your Miro apps with Salable!

Salable — Tue, 03 Sep 2024 15:46:44 +0000

We're thrilled to announce our new collaboration with Miro🎉

Our guide on monetising your Miro apps using Salable is now live on their developer documentation site! 📚✨

Developers, this is your chance to seamlessly leverage our powerful Salable platform for all your monetisation and licensing needs. With our guide, you'll have all the tools and insights you need to turn your innovative Miro apps into profitable ventures. 💡💸

Why wait? Dive into the guide today and start maximising your app's potential!

Grab it here 👉 https://developers.miro.com/docs/monetization-with-miro-salable

If you want to learn more about Salable, you can check us out here 😊 https://salable.app

Streamline your SaaS: why Salable is the game-changer for app developers

Salable — Fri, 03 May 2024 12:13:18 +0000

SaaS developers are a unique breed. They face a labyrinth of challenges, from coding and UI design to the intricacies of payment processing. While platforms like Stripe have been go-to solutions, many developers find themselves wrestling with systems that, although powerful, can feel like trying to navigate a crowded market with an oversized backpack. They’re impractical and often miss out on crucial features needed by SaaS products — most notably, a robust user licensing model.

Enter Salable: your new secret weapon in launching and managing your SaaS application with unprecedented ease.‍

Speedy development meets real user licensing

Imagine if you could wave goodbye to the complexities of licensing models, bid farewell to the perplexities of subscription management, and say hello to more time innovating and less time fretting about operational details. That’s not just wishful thinking — it’s what we offer at Salable.

One significant headache for many SaaS developers is finding a platform that understands their needs — not just in handling transactions but also in managing real user licenses effectively. Traditional platforms often leave much to be desired here; they’re like square pegs for round holes — close but not quite right.

Salable changes the game by integrating these critical features right into its core functionality. This means you can set up user licenses that match your app’s needs without juggling additional software or plugins — a move that’s bound to streamline operations and slash your time-to-market dramatically.‍

Monetisation made simple

Let’s talk money-making because let’s face it — that’s why we’re all here! With Salable, monetisation isn’t just an afterthought; it’s woven into the fabric of what we do. Whether you’re exploring subscription models or looking for more complex commercial arrangements, our platform makes it effortless.

From recurring payments to one-time transactions, everything is handled within our sleek interface designed with both speediness and handleability in mind.‍

Grow effortlessly

But where would all this be if it didn’t help you grow? Scaling up should be exciting — not exhausting. Our tailored services ensure that as your user base expands or as you refine your offerings based on feedback without missing a beat.

The future-proof design keeps pace with evolving tech landscapes so you can concentrate on bringing new ideas into reality rather than being bogged down by backend hassles.

Conclusion: make space for innovation

In today’s fast-paced digital world where every second counts towards success or stagnation, having tools that are not only functional but finely tuned for SaaS development could mean the difference between blending in or standing out.

Salable isn’t just another tool — it’s an ally for developers who dream big but are weighed down by operational inefficiencies. If transforming ideas into impactful software experiences quickly is what drives you then pivoting to Salable might just be one of your best moves yet.

If the idea of cutting-edge software development without the usual constraints grabs you (and frankly why wouldn’t it?), then welcome aboard — the future looks bright from here!

Simplify authentication and monetisation with Clerk and Salable

Salable — Thu, 11 Apr 2024 08:51:29 +0000

When it comes to rapidly implementing secure authentication in your application, it doesn’t get much simpler than Clerk. Create an account, implement some pre-built components, and you’re done!

So you’ve now got authentication, but you wanted to make a paid product — what next? This is where Salable comes into the picture.

Salable is a platform that allows you to implement flexible licensing/monetisation without all of the headaches. We make it simple to take payments and authorise users in your system.

Clerk allows you to implement auth in hours instead of days, Salable aims to do the same with licensing and payments.

And guess what? They fit together like two peas in a pod.

In Salable, we have the concept of a Grantee — this is anything/anyone that you’d want a license to belong to. It could be a team, it could be an individual user, it could be a Trello board, anything!

Clerk provides us with a userId for our authenticated user. Here is an example of fetching it using the @clerk/clerk-react package:

import { useUser } from '@clerk/clerk-react'const 
{ user } = useUser()const granteeId = user.id

We can now use this granteeId value with any of the Salable SDKs (or our REST API) to start accepting payments.

Let’s look at an example of checking a user’s license capabilities with @salable/js:

import { getGrantee } from '@salable/js';
const { hasCapability } = await getGrantee({  
apiKey: 'your-salable-api-key',  
productUuid: 'your-products-uuid',  
granteeId, // 💡 this is using the `user.id` from Clerk
});
const isUserLicensedToPerformAction = hasCapability('your-capability-name');

And that is all there is to it. You can now use your Clerk authentication setup to accept payments and run license checks for authenticated users.

To learn more about what methods and functionality Salable offers, check out our documentation site.

For any questions on any Clerk and Salable integration tips and tricks, you can visit our Discord channel.

Per-seat (per-user) billing - make money with this flexible pricing model

Salable — Wed, 14 Feb 2024 13:02:43 +0000

In this software-as-a-service (SaaS) era, finding a pricing model that's simple, scalable, and predictable is like finding a pot of gold. Enter per-seat billing (also referred to as per-user billing), the popular kid on the pricing block.

With this model, the price your customer pays depends on the number of user licenses needed. This could be a number of specified users or a number of Trello board IDs, for example.

Before we dive into how to implement per-seat billing via the Salable platform, let's explore some of the perks of this pricing model.

‍

Benefits of per-seat (per-user) pricing

It's as easy as 1-2-3 Imagine your customer pays $50 per seat per month. Add more seats, and the price doubles, triples, and so on. It's simple maths! No mind-boggling calculations here. So, taking the above image as an example, your customer understands that their monthly subscription would be $50 x 12 = $600. It's a piece of cake!

2. Your revenue grows with their squad

As your customer grows and hires more awesome people, their subscription fees will increase accordingly. That means your revenue scales with their adoption. It's a win-win! And your customers only pay for the level of service they need, giving them a predictable cost.

Full access for all With per-seat billing, everyone gets equal access to all the fantastic features. There are no hidden fees or restricted access based on subscription tiers. Everyone can unleash their productivity without any limitations. Collaboration, here we come!

4. Get teams on board quickly

When pricing is based on headcount, getting your customer's entire organisation on board is super easy. There's no need to worry about extra costs for specific features or limited functionality. Everybody gets access to everything right from the start. It's a great way to drive adoption and keep teams engaged.

5. Budget like a pro

Budgeting and cash flow forecasting just got a whole lot simpler. With per-seat billing, your customers can easily calculate their cost by multiplying the number of seats by the per-seat price. No more headaches! They'll know exactly what they need to pay, helping them make informed financial decisions.

‍

At Salable, we understand that monetisation plus flexibility is key. That's why we've introduced per-seat billing. Whether your customers are small startups or big-shot enterprises, this pricing model adapts to their needs. They only pay for what they use, allowing them to scale up or down effortlessly!

‍

So how does per-seat billing work on Salable?

Simplicity and ease is our mantra. At Salable, we don't like to overcomplicate things. We're here to help you get set up easily so you can make money with this pricing model.

‍

So why wait? Experience the flexibility and value of per-seat billing with Salable, and simplify your billing process today. It's totally free to sign up, plus you can play around in our test mode environment, so there are no strings attached. Go ahead, give it a try! To get started implementing per-seat billing get early access here, and check out our documentation for more info!

Salable was created by developers, for developers

Salable — Mon, 15 May 2023 09:21:38 +0000

Did somebody say an all in one SaaS platform? That's us 🙌

Flexible licensing ✔️
App monetisation✔️
Subscription management✔️
and lots more! ✔️✔️✔️

We do all the heavy lifting and help you turn your product concept into a successful revenue-generating business. Sound exciting?

We understand the frustrations that come with existing commercial solutions, which is why we set out to build an easy-to-use tool that simplifies the process of setting up a SaaS business.

Salable is designed for app creators, small app vendors, and SaaS start-ups who want to turn their product concept into a successful revenue-generating business.

With Salable, you'll only need to learn one efficient tool to manage, monetise, and develop your business. Our platform streamlines the integration of payment providers, analytics tools, marketing, and other business tools, so you can focus on building your business while we do the heavy lifting. Trust Salable to take care of the hard work and help you succeed...

https://www.salable.app/

Using a private GitHub repository as an NPM package in another repository

Salable — Thu, 13 Apr 2023 12:35:09 +0000

Creating NPM packages is an easy and convenient way to share code across multiple projects. But, if you want to keep the package private and are unwilling to pay for the premium features of an NPM account, you’ll hit a bit of a sticking point.

This is the situation we found ourselves in recently with our Global Design System (GDS) package for Salable. While the eventual goal is to open source the package and have it freely available on GitHub and NPM, in the short to mid-term we wanted to keep the package private until we had a core offering to release. But this meant we needed to find a way to install our private package into our Salable repository without running a high-bill on NPM user accounts, just so we could publish a private package on the NPM registry.

But not to worry, because we can install our package directly from our private GitHub repository using SSH.

Pre-Requisites
Prior to being able to install from a private GitHub repository, you need to ensure it’s set-up correctly. I won’t be covering the exact details of setting up a repository in this post, but in essence we need to make sure our package is being built into an output directory like dist. We also need to ensure ourpackage.json file has the main, module, name and files properties configured.

For example, these properties could look like;

‍

{
  "name": 'some-package-name',
  "main": "dist/index.js",
  "module": "dist/index.es.js",
  "files": [
    "dist"
  ]
}
‍

These properties give information about the package contained in the repository. Most notably are the files and name properties. The files property controls what files will be installed when a user installs the package, in this example we want to only install the built files in the dist directory. And the name property is the name of the package that will be added to the package.json of the project you’re installing into.

Local Setup
For us to install the package contained in our private GitHub repository, we need to ensure we have SSH access configured with a GitHub account that has access to the private repository. If you don’t have SSH access configured, you can follow GitHub’s guide here.

You can test your SSH access with the command ssh- T git@github.com (enter ‘yes’ if prompted to confirm the fingerprint match). If the command is successfull you should see a personalised welcome message printed out to the terminal.

With your SSH access configured, all you need to do is run an install command using your GitHub username (or organisation name) and the repository name like npm install user(organisation)/repository-name or yarn add user(organisation)/repository-name if you’re using yarn. For example yarn add exampleUser/exampleRepo .

It is important to note the repository name used in the command is the GitHub repository name and not the name field in the package.json mentioned in the last section.

Bitbucket Pipelines Setup
For us, the repository we would be installing the GDS into, it is hosted on Bitbucket and utilises Bitbucket pipelines for CI/CD. This means we will also need to configure a way of installing the GDS package via Bitbucket pipelines.

Luckily this can be easily achieved by adding in an SSH key for our pipelines to consume. Read the documentation here if you’re interested in learning more.

To set this up, you’ll need to log into your Bitbucket account and head to your ‘Repository Settings’. From there, scroll down on the side menu until you see the ‘Pipelines’ category and the ‘SSH Keys’ option within it, then click on ‘SSH Keys’.

Then on this page, you’ll need to add in the private and public keys for the SSH key you configured earlier for access to GitHub. With those keys saved, Bitbucket pipelines is now configured to install the package hosted on our private GitHub repository.

NOTE: In your pipelines configuration file you may also need to append ||true to any yarn install commands. Otherwise the step might fail due to installing from a GitHub remote source like this, the error fatal; not a git repository (or any of the parent directories): .git: is generated, triggering the pipeline to error. But the package is still installed even with this output.

Vercel Setup
Now the final part of our setup is configuring Vercel to be able to access the private repository as well. You might be thinking “Let’s just do the same that we did for Bitbucket…” but unfortunately that isn’t possible, as Vercel doesn’t allow you to add SSH keys like Bitbucket does.

Instead of installing it via SSH we’re going to do some git config editing to use HTTPS authentication instead. What this means is before the yarn install or npm install command is run, git will have switched the package remote path from an SSH string to a HTTPS one using a Personal Access Token (PAT) for authentication.

And as Vercel already have a great guide on installing private NPM dependencies using HTTPS, we should be able to install our private packages with no issues.

To setup this up, the first thing we need to do is generate a Personal Access Token on GitHub which you can do by following their guide here. The important thing to note is when you create the token, the token’s scope should be set as repo to let it access all your private and public repositories.

With your token generated, add it to your Vercel project as an environmental variable with whatever name you wish to use. After adding your token added to Vercel, we need to setup an install script for our project, so create a new file in the root of your target repository called install.sh and add in the following contents to the file.

git config --global url."https://$YOUR_TOKEN_NAME:x-oauth-basic@github.com/".instead0f ssh://git@github.com
yarn install 1>/dev/null;

‍

NOTE: Make sure to switch the YOUR_TOKEN_NAME to your actual token name that you just added to Vercel. Also make sure to mark the script as executible by running chmodtrue +x ./install.sh
Finally revisit your Vercel project and under ‘settings’, set the ‘install command’ field to./install.sh so it runs the script we just created for installing dependencies.

You should be able to install your package from your private GitHub repository on Vercel.

Conclusion
In this post, we’ve covered everything needed to be able to install a NPM package directly from a private GitHub repository on local machines, Bitbucket Pipelines and on Vercel. I hope you found this post helpful.