Tiered Membership with Tyler Bell, Co-Founder of Memberstack

Transcript

[00:00:00] John Britton:

Hello, and welcome to the Yes-code Podcast. I'm your host, John Briton, and today we're talking to Tyler Bell Co-founder and Engineer at Memberstack.

I'm really interested in today's episode because they're building a product at the intersection of two really big problem domains, authentication and payments.

Let's get started.

Hello and welcome to the show, please introduce yourself. Who are you and what do you do?

[00:00:23] Tyler Bell (Memberstack):

My name is Tyler Bell. I'm a Co-founder and software engineer at Memberstack. Been working on Memberstack now for, I think it's been a little over two years now, and started it with my best friend, his name is Dunkin Hammer, he's the other, other co-founder and, yeah, we've been going at it ever since and it's been really, really been, it's been a fun project to work on.

[00:00:45] John Britton:

When you say you're software engineer, can you tell me a little bit more? Like what kind of engineer are you, what do you focus on? What are your kind of tools of the trade?

[00:00:52] Tyler Bell (Memberstack):

I would definitely consider myself more of a kind of web developer. I went to college for computer science. I do have a computer science degree, but I'm primarily what I do on a day-to-day basis is definitely more kind of web-related and the tools that I choose to pick up are JavaScript and TypeScript. All of our APIs are written in TypeScript we're using GraphQL, we're using REST APIs. Our frontend is built in React.

[00:01:17] John Britton:

Thanks for sharing.

I love programming. I'm a software engineer, but I also love to hate programming. I sit down and I have like an idea of something I want to build and I'm always overwhelmed with the fact that I have to start from like the tiniest little building blocks out there and the more and more I, I get this feeling the more I find myself wanting tools that solve higher level abstractions for me.

So I've been working on this project, Yes-code, and I want to talk to builders behind tools that are giving developers high level primitives that they can mix and match to make very unique solutions for what would be normally a complex problem, but with like a better abstraction.

Can you talk a little bit about, what motivates you as a programmer? Are there things that annoy you, that, that make you build the way you do? What informs your philosophy when it comes to building developer tools?

[00:02:13] Tyler Bell (Memberstack):

Really what it comes down to is I really like building tools that I want to use myself. The whole reason why we started Memberstack is I had a big issue where we were creating a lot of side projects and a lot of these side projects had the same requirements over and over again. And in Memberstack's case it was we needed authentication and we needed payments. And I didn't want to have to recreate payments and authentication every time I went to go pick up a side project or go to start building a side project.

And I went and I tried to find solutions out there that had higher level functionality that I could just kind of plug into these side projects and I couldn't really find anything. And that's really what sparked the whole idea behind Memberstack in the first place.

And the goal became, can we build a product that actually makes it easier to integrate authentication and payments at a higher quality that you normally could do by yourself if you were doing it all custom?

So I would say that kind of the philosophy at Memberstack is we're trying to build a product that's actually like 10 times better than anything that you would build yourself and you can do it faster.

So any type of feature that we try to add or any really any decision that we make, that that's kind of the question that we ask ourselves, is this actually going to be better than what you could build yourself and are you going to be able to implement it faster than you could yourself?

[00:03:33] John Britton:

I think something that's interesting too about that is how you mentioned the intersection of two big problem domains. There are a lot of tools out there for the really fundamental building blocks, whether that's block level storage with something like Amazon S3 or charging a credit card via Stripe.

But, the intersection of membership and payments is a very specific problem with solutions that can take a lot of time and have a lot of complexity. And so specializing in something that is really reusable, but also is focused on, that sweet spot between those two domains is really interesting to me.

[00:04:12] Tyler Bell (Memberstack):

The majority of the challenges that we faced are really kind of around that intersection, because it's a great point, because there's a lot of companies and a lot of services that do authentication. And there are a lot of companies that do payments and they all do that one part extremely well, like Stripe's an example of this, Auth0 is an example of this, like there are tons of examples of companies doing one part extremely well.

It's another thing that we kind of have to ask ourselves at Memberstack, if we're trying to do both, are we going to be able to provide the same level or the same quality of service for each particular part, the other companies are just solely focusing on.

And it also kind of led us down this road of, we don't want to recreate really anything that's already available. So instead of trying to rebuild Stripe, we just leveraged Stripe. We use the Stripe Connect product, where someone can leverage their existing Stripe account and we can, you know, use the full power of Stripe and our own product and same thing on the auth side, like we use a couple of open source tools that make authentication easier, and we don't, we didn't want to kind of recreate any of the awesome technology that's already out there.

And essentially what we're doing is we're just trying to bridge the gap and kind of bring them together, at least from the auth and payment standpoint.

[00:05:21] John Britton:

That's something I've noticed is there's this kind of orchestration layer that's really annoying to build in a lot of cases and can be better solved if somebody who's an expert in that space just gives you that kind of orchestration already made and that includes things like admin tools and so on.

The first thing I wanna talk about is the problem space. What makes managing memberships and payments so difficult? Like what are the things that are actually hard here and why do I need something to help me get this done?

[00:05:49] Tyler Bell (Memberstack):

I would say, really, the problem that we're going after are the folks out there that need to set up payments and they need memberships and user login functionality. Because, at the end of the day If you just need payments and you're not worried about user log-ins or, you know, you're selling some sort of product that's kind of off-site, you know, you can just pick up a product that's already on the shelf today like Stripe, for example.

But, I think what makes the problem of user login and payments and plans and memberships complicated for a lot of folks, is it introduces a lot of moving pieces.

Because now when you have a user, for example, that they sign up for your application and they want to be able to do something within an app that you're building or in a website that you're offering them. And you need to associate information with them such as like a customer in Stripe. I'm just going to use Stripe as an example here, you now have to kind of create a layer to sync your member that you're storing in your own database with Stripe.

And now you need to set up webhooks and especially nowadays, there's a lot of, kind of new laws that are coming in place, especially in Europe where processing payments is becoming increasingly more difficult. And there's a lot more complexity today than there were a couple of years, years ago on payments and trying to keep your members and your database synced with Stripe, it's not necessarily an easy problem solve.

At the surface level, just trying to get a simple kind of sync happening it can be fairly simple, but once you get into more like nitty gritty details, it becomes a bigger problem.

[00:07:23] John Britton:

So you mean things like a user upgrades their plan level or cancels mid month and you have to do proration or what kinds of complexities are, are you seeing, like in the syncing layer? .

[00:07:34] Tyler Bell (Memberstack):

One of the things that comes top of my mind right now is around the different kind of status types that Stripe has been providing because one of the new status types that they provide, they've just released over the past couple of years is the status types that allow you to support strong customer authentication.

Kind of a common flow that people don't realize they need to account for and then later find out they do is imagine you have a customer that lives in, let's just say Europe and they have a credit card and their credit card requires SCA, which stands for strong customer authentication. It's kind of a new law that's been out for the past couple of years and it started in Europe but now it's spreading globally.

[00:08:15] John Britton:

Is this the thing where when you make a charge online, it opens up like a credit card company website, and you have to go through and like authenticate with them? Is that what you're talking about?

[00:08:22] Tyler Bell (Memberstack):

Exactly. It's exactly that. And what's interesting about it is that can occur off-site. When I say off-site what I'm essentially saying is like the member could try to process that payment, the bank could flag it and say, "okay, this, this user needs to authenticate this payment," and instead of having that be kind of a synchronous process the bank might send them a text, so they might be doing the, the authenticating on their phone, whereas they're on the computer.

So you have to listen to certain webhooks from Stripe and implement certain things from Stripe's APIs that allow for you to kind of listen in to, to know if that payment was successful and it all happens kind of asynchronously. It creates extra complexity on your applications backends in order, to do that.

[00:09:08] John Britton:

Yeah, it sounds like there's a lot of touch points for integrating payments and also for integrating, you know, kind of membership levels as well.

When you initially started building Memberstack, what was the thing that motivated you? Did you have a particular product you were building and then, you know, you needed Memberstack or was there some other kind of origin?

[00:09:27] Tyler Bell (Memberstack):

We built Memberstack because we wanted to use the product ourself. We wanted to build a product that we would actually use ourselves. My business partner and I had, Duncan and I, we were, at that time, we were working on a product called Formatically and , it was a product centered around college students and high school students where we wanted to make it easier for college students and high school students to be able to format their papers.

In the process of building that product, we got to the stage of "like, okay, we need people to be able to log into this application and we need people to be able to pay for this application."

So I started doing a bunch of research on different ways to authenticate users and different ways to process payments and I found Firebase and Auth0 and found Stripe and Chargebee and kind of found all these different moving pieces that solved one part of the puzzle.

But I wanted to try to find a product that allowed us to do the auth and the payments at the same time. And I couldn't find anything. Duncan and I, we were just kinda talking one day and we're like, "you know, it might actually be an interesting side project to kind of spin up a product that we would actually like to see exist and let's build it and use it in the product that we were building," which was Formatically, at the time and we built it and we shared it with a couple of communities and it kind of blew up and people were like, "please keep improving this." And we were like, "all right, this. Is now our full-time gig."

[00:10:42] John Britton:

So the side project became the main project.

[00:10:45] Tyler Bell (Memberstack):

Exactly. Exactly.

[00:10:47] John Britton:

So I want to talk more about Memberstack and about this kind of space of authentication and payments.

How do you define what the boundary is for Memberstack? I'm sure you get a lot of user feedback for things that you could add, and it's always hard to say no, but what you leave out is really just as important as what you put in. What kind of guiding principles do you have for Memberstack?

[00:11:07] Tyler Bell (Memberstack):

So I will say boundaries for Memberstack has been quite the journey. Because initially, if someone sent us an email and they're like, "Hey guys, you really need to add this feature." We'd be like, "great. We'll add it, we don't care if it's going to take us three weeks to add this feature, we're going to do it."

We pretty much said yes to everything in the beginning. We have a motto now called "simple first, powerful later."

[00:11:27] John Britton:

Oh, I like that.

[00:11:29] Tyler Bell (Memberstack):

Yep. Simple first powerful later. Someone in our, in our team will, we'll say it in Slack just about every day. The whole mindset is, it's like, we want to build an extremely simple product today that works extremely well and we don't want to add complexity to it that we don't necessarily know if we need to add to it just yet.

Another thing that we want to consider is in a typical working day, we all have limited hours and we want to make sure that we're spending those hours on features that add the most value to our customers. For example, we don't want to spend two weeks working on a feature that only one of our customers can utilize.

[00:12:03] John Britton:

So say I'm considering this for my side project. What's the first run experience like for a developer integrating this, like where are the touchpoints? What are the simple first things they have to do, and, how does the implementation go?

[00:12:15] Tyler Bell (Memberstack):

This is something that we've definitely like refined over the years and where we're at right now with that is we want to make it a really easy to use, out of the box experience. Like we want to provide something that just works out of the box with minimum effort.

And then if you want to go in and tweak it or add to it, then you can, but we want to make it where you can literally create an account with Memberstack, you can go clone one of our projects, and instantly works.

You're not kind of to having to like add memberships, you're not having to through settings. We want to make sure that the project that you spin up is going to work out of the box and then you can go in and you can tweak it and edit it and you know add your own plans.

[00:12:51] John Britton:

Things like making bronze, silver, gold, different price ranges, all that kind of stuff comes out of the template and then you can tweak it how you want.

[00:12:58] Tyler Bell (Memberstack):

Exactly, exactly.

[00:12:59] John Britton:

What's the touchpoint for a developer, you know, what am I actually integrating into my code base?

[00:13:04] Tyler Bell (Memberstack):

As a developer, you have a couple of different options.

If you're a developer that is utilizing a website builder, such as Webflow, we have a very specific package that we're calling our Webflow package that integrates with Webflow, um as a header script. So you just add a header script to your site.

But if you're using like Vue, for example we have an NPM library that we're calling @memberstack/dom that allows you to, it's essentially a wrapper around our API. I think we've got like, almost like 25 different methods that you can call on that on that library.

But if you're using React, for example, we have a, we have a NPM library that specific to React, that wraps our DOM library makes it easier for you as a developer in React to utilize Memberstack.

[00:13:47] John Britton:

Yeah, and I understand just from tracking Memberstack for a while, that there's definitely a contingent of your customers who aren't developers, right? You have people who are using Memberstack kind of as like a no-code tool as well.

[00:14:01] Tyler Bell (Memberstack):

Right. Yeah, that is correct. And I will say that's where, that's where we had our start as a product.

[00:14:06] John Britton:

So what precipitated this change to more developer focus.

[00:14:10] Tyler Bell (Memberstack):

When we started the majority of our users were essentially no-code users. So these were people that, that didn't necessarily know how to code, or these were people that were contracting with developers to integrate Memberstack for them.

In the beginning, we were trying to build a product that anyone could integrate, , whether they knew how to code or didn't know how to code we wanted to build a product that was so easy to use for example, like say like a business owner didn't know how to code to be able to kind of integrate Memberstack.

And over time we really found that the customers that were most successful or that we saw that were most successful were people that could kind of solve their own issues when they reached blockers.

Whether it was with a, like a blocker with Memberstack, or maybe they were using like a website builder that was blocking them. And the folks that knew how to code the developers that were using the product and knew how to code, they very rarely would run into a blocker because, if they ran into a blocker they would just kind of write their own custom code and throw it up and build a solution and they would be able to keep moving on.

Whereas more with like the no-code crowd it was definitely more difficult for us to continue building a product that kind of worked for everyone. It was kind of like an kind of a long-term decision we made where it's like, okay, like developers, like, we're seeing that developers are actually more successful with Memberstack than your typical no-code user.

So let's double down on these developers that are using Memberstack and try to figure out what would it look like if we built a product that was tailored more towards those advanced developers, more so than just a typical no-code user.

[00:15:32] John Britton:

No-code is great. I love no-code tools.

I use them all the time, but they're incredibly frustrating to me as a developer in a lot of cases, because, while they give you the building blocks to do things, usually within a walled-garden, that if you fit the format that the builder expects you to use it's very easy to do.

But it's limiting when you want to do something custom or when you want to compose it with lots of other tools, because whenever you wanna compose a no-code tool with another no-code tool, you depend an existing integration and you don't always have the option to write that integration yourself.

And as a developer and kind of one of the key principles behind Yes-code for me is that it's in your own codebase. Therefore, if each of these tools is giving you some primitives, whether it's a user or a membership plan or something else you can put them together however you want and use code as your glue. And at the end of the day, you can make it work.

You know, it's not as elegant as a no-code solution, but for anybody who knows how to code, it's a really, much more natural feeling.

On that note, I would love to talk to you about the primitives of Memberstack. What are the things that you expose to developers that they can compose and remix the way that they want to?

[00:16:44] Tyler Bell (Memberstack):

This is actually kind of part of the story of Memberstack the evolution we've had as a product going from more of like a no-code product to a product that we want to tailor more towards advanced developers.

In the version one product of Memberstack, it was pretty much a closed system. What we offered out of the box was pretty much what you got. And if you wanted to tweak it or edit it the solution was sending us a feature request to try to get us to add the thing that you would want. And it was very closed off. It was essentially a closed system.

An example here is any time you would want to say open a log-in UI that was provided through Memberstack, you would have to add a data-attribute to a button that a user would have to click on in order to open the log-in modal.

We would get countless feature requests saying like, "hey, I just want to call a function and open up your login modal." Don't make me add a data-attribute to a button that someone then has to click on in order to open the log in modal. Just give me access to the raw functionality where I can just open your login modal.

That led us down this road of saying, okay, literally everything that we build now, we want to make sure the developers can directly access it.

I briefly mentioned the DOM library because really the core of our product really comes down to what we're calling @memberstack/dom, and it is the library that operates, really in any sort of client side application, whether it's Vue, React, as long as it's running in browser, it can be used.

[00:18:05] John Britton:

So is @memberstack/dom like the fundamental layer and then you'll have like your Vue wrapper around that and your React layer around that.

[00:18:12] Tyler Bell (Memberstack):

Exactly. So everything consumes the . DOM library. So the DOM library is, for example, I think we have about 25 different methods and the simplest method would be loginMemberEmailAndPassword. So this is a method that you can use as a developer to pass an email, pass a password, and if email and password match in, in the database, you know, you're going to get back into authenticated member.

Another method that we have for example, is called openModalLogin. So if you don't want to have to deal with building your own login UI, and you just want to rely on our login UI, you can call openModalLogin.

So as a developer, you're able to do that, but all of our other packages that we have that make it just slightly easier for you as a developer depending on where you are. So for example, if you're in React, we have a React package that consumes the DOM library it's essentially a wrapper around the DOM library that provides React hooks for example. To just make it a little bit easier to control Memberstack within a React application.

[00:19:11] John Britton:

How do you coordinate that development across the DOM library and then the wrappers within each of the different frameworks that you're supporting? I could imagine that something changes, breaking change, or an improvement happens in the DOM library, and then you've got to across all the frameworks that you support. So how do you handle that?

[00:19:28] Tyler Bell (Memberstack):

So I'll be the first to admit that that's a process that we're still trying to improve, that specifically has been a little or struggle for us just because we are fairly new to the package game.

And one of the things that we've done is really everything starts with the DOM. So if we add a feature that we want to make available to Vue developers, React developers, or Webflow developers, we're going to first add it to the DOM library. Then, once it's added to the DOM library, that's when we'll then go in to say like the React library, for example, and expose that new functionality to the React library.

[00:19:59] John Britton:

So you shared a bit about V1 and the evolution of Memberstack. Can you tell me what are the building blocks that you give to developers as primitives so they can customize their experiences?

So for example, we talked about plans, we talked about members, we talked about payments, what are the nuggets of functionality that you've built that hide complexity from the user?

[00:20:19] Tyler Bell (Memberstack):

At our core we're going to start with a member. So everything starts with a member. You're signing up members, you're logging in members. And since our main company goal is to make it easier to add user accounts and payments at the same time, we're going to add functionality to that member that you typically would have to build in yourself if you were doing a custom solution.

So an example would be so you have a member you want to log that member in but now you want to add a plan to that member. Now you're essentially saying, "Hey, here's this member they just logged in and they want to upgrade and they want to pay $25 a month for a plan in order to get access to a certain part of my application." So in order to do that with Memberstack, that's where plans come in.

In the Memberstack dashboard, you're able to configure plans, you're able to configure pricing options, but more importantly, you're also able to enable and determine what the user gets access to if they have an active plan and we have a permissioning system that allows you to create permissions and assign those permissions to plans.

And essentially from Memberstack's perspective, if you have access to a certain plan to unlock certain permissions, that member will then have access to this permissions. And it really lets you as a developer build a application based on, it was kind of like a role-based application that you're able to just respect Memberstack's, permissions, and say, "okay, this member has permission a so therefore we're going to give them access to this part of the application."

Just to kind of loop back around on the user log in and kind of payments kind of aspect here. We do attach methods to those members just to make it even easier and we have a lot of different payment related methods where once a member's authenticated into your application you're able to call member.purchasePlan and you're able to pass in a planID that you create in the Memberstack dashboard and Memberstack will automatically handle all the complexity associated with signing that member up to that plan and purchasing that plan for that member.

If you were building this yourself with a custom solution that would be all custom code. You would then have to sync that data between Stripe and your own database and that's just something that Memberstack is going to handle out of the box for you.

[00:22:33] John Britton:

How do you handle edge cases and things like having tiers of plans and upgrades and potentially different access levels for those plans.

So say like on day one a user joins and there's a free plan and they're on for 30 days. And then after 30 days, they upgrade to bronze for 20 bucks a month, but then 15 days later, they upgrade to silver for 50 bucks a month.

How do you handle that kind of stuff and what are you removing from the developer's plate with Memberstack in those situations? Because I know there's complexity around that stuff.

[00:23:05] Tyler Bell (Memberstack):

The first thing that we're removing from the developer's plate is the logic to even process those upgrades and downgrades.

For example if you're building a website that say has three tiers, so you've got "basic," "pro," and "premium" and you want your members to be able to navigate up and down those plans to get different access.

If you weren't using a service like Memberstack, like that's the logic required to do that? Like you're going to be building that logic in yourself.

And when I say yourself you're having to determine the plans and the pricing options that you want to make available and you're having to build in the backend functionality.

For example, let's just use Stripe as an example here. It's calling the Stripe API to update the user subscription and then you're having to listen in for webhooks to verify that the subscription creation or update was successful and if it was you're going to have to update your own database.

But with Memberstack what you're able to do essentially is you're able to have a UI, add your different pricing options and, have a single function call that will handle the upgrade and downgrade logic for you.

We've introduced quite a bit of flexibility with this, for example, it's like, if you want an application that supports multiple plans, that you want your members to have multiple plans at the same time, you're able to do that.

You as the developer, you have the choice of determining what you want to be possible in your application, through a single function, without having to go to your backend and create a lot of different complexity and code that can handle those different flows.

[00:24:30] John Britton:

I wanted to ask you about price changes, not just like the dollar amount of the price change, but. For example, say, you have a grid of 15 features and only the first four features are available on the "basic" plan, and, you know, it goes up on each plan. Assigning features to plans and handling the change management of that or changing the pricing.

How does Memberstack handle that and does it help me as a developer or as a product owner in figuring out what pricing works for my product?

[00:24:59] Tyler Bell (Memberstack):

It's a common request from our users where they do want to experiment with different pricing options very quickly

When we went back to the drawing board, when we were building the new version of Memberstack it's something that we wanted to make really easy. The way that we've went about this is Memberstack you have plans and plans to Memberstack would essentially be a, a tier. So this would kind of be like your "basic" plan, your "pro" plan, your "premium" plan, and the plans are kind of what to doing your feature unlocking.

So if you have 15 features and your "pro" plan unlocks 15 features and the Memberstack dashboard is essentially where you would create that plan and then assign the permissions to that plan that should be made available. If they have access to it.

That's kind of at a plan level. But then if you go one level deeper into a plan, you have prices and in Memberstack, you can have unlimited prices to a plan. So you could have as little as one pricing option for a plan, or you could have a thousand, it doesn't matter

And what it allows you to do is you can go into a particular plan in Memberstack and create a price and all the settings that are on that particular plan will apply to that price.

You could have say 30 or 40 members sign up for that particular price and you might decide, "Well, Hey, I want to increase the price of this plan for $10" and you can easily go into Memberstack and add that new pricing option in.

[00:26:21] John Britton:

Does that allow you to do things like let your existing customers keep the pricing they had, while offering new customers a different price? I know this is something that comes up years down the road, but maybe you made an error with your pricing up front and you want to rectify it, but you also want to treat your customers well, and also not add tons of complexity to your back end, right?

So at the end of the day, it sounds like they're all on some plan. Just some people paid one price and other people paid a different price.

[00:26:48] Tyler Bell (Memberstack):

Exactly, exactly. And you as the developer and kind of as the business owner, that decision is left to you so you can grandfather your users in, you can also, you know, make the decision where it's like, well, I want to make sure these users have access to this old plan for a year and then after a year I want them to transition.

You as the developer and as the business owner can make that decision to add that logic in.

[00:27:08] John Britton:

Where did you get your inspiration from this? What caused you to design the system in this way? Was it based off of past experience? Was it, was it based off of some kind of, you know, known good pattern, where did this come from?

[00:27:20] Tyler Bell (Memberstack):

We didn't want to rebuild anything that just works well out of the box.

Like we didn't want to have to come in and build Memberstack in terms of replicating authentication that might already be available, replicating payment functionality that's already available. So since our main, at this point, our only payment integration is Stripe, the way that Stripe handles things heavily influenced what we wanted to enable with Memberstack.

We used Stripe, as our inspiration on the payment side just because a lot of people really enjoy using Stripe and it was already familiar. Yeah, so Stripe is definitely our source of inspiration on the payment side.

[00:27:55] John Britton:

Who's using Memberstack, what's the typical profile of a user, and who are you targeting and why are you targeting them with this product?

[00:28:04] Tyler Bell (Memberstack):

That is something that's definitely evolved over time. So at Memberstack's start, like we were definitely considered more of a no-code product and we had a lot of no-code users using us. Like the majority of our customers were no-code users and over time that's definitely shifted to being more and more advanced no-code users until more recently it's shifted to developers, using Memberstack.

And what's really interesting is since we really had our start in the no-code space and like just being, even more specifically, like in the Webflow space, notice that the customers that are getting a lot of value out of Memberstack are the developers that are using Webflow.

They're using Webflow to build out their marketing site. They might be using Webflow to build out their UI for their application. Those are the users that at least short term that we're targeting. That we're going after, because based on what we're seeing right now in our product, like those are definitely the folks that are getting the most value out of Memberstack.

[00:29:04] John Britton:

Were there any use cases or applications of Memberstack that caught you off guard or surprised you when you found out about how people were using the product?

[00:29:14] Tyler Bell (Memberstack):

This is something I never thought I would, I would see someone using Memberstack for this, but, recently I discovered that one of our customers is using Memberstack for a Chrome extension.

And we even have another customer of ours using Memberstack for an Alexa app.

They're using Memberstack to authenticate users through Alexa and the Chrome extension works very similar way, where they wanted people to be able to log in through their Chrome extension and they're using Memberstack to do that.

[00:29:41] John Britton:

I'd be interested to know like more how the Alexa one works. Is it like, you log in via voice?

[00:29:46] Tyler Bell (Memberstack):

I believe so. I believe so and I think once you log in it gives you access to data that you're essentially paying for.

[00:29:52] John Britton:

Ah, I see. Then it's like a paid Alexa skill.

[00:29:55] Tyler Bell (Memberstack):

Right, right.

[00:29:56] John Britton:

Okay. Interesting.

We've talked a little bit about this already. The idea that you're focusing more on developers, but what do you wish that your product could do and what are you building towards next?

[00:30:08] Tyler Bell (Memberstack):

What I wish Memberstack was able to do today, as a company, that's trying to make it easier for users to authenticate and process payments, I wish we had more authentication methods today. Right now we only support email and password and Google auth and Facebook auth.

But pretty much every day we get feature requests where people want to be able to authenticate with Twitter and LinkedIn and single sign on and OpenID Connect on that kind of like all the different kind of authentication mechanisms out there.

In the future, what we're really trying to achieve. Is we really want to enable all the functionality of Stripe through Memberstack.

For example, like Stripe, lets you do tons of different things. Like there's tons of different configuration options, especially around plans and prices. Like you can have quantities, you can update billing anchors and we really want to make sure that if you can do it in Stripe. You can do it in Memberstack.

Because right now, Memberstack supports a subset of what Stripe supports and every day we're just trying to expand upon what we do support and make available, through the Stripe API.

[00:31:09] John Britton:

It seems like it's a lot easier to use than using Stripe directly. I mean, again, I love Stripe. I can talk about, you know, how much I love using Stripe all day, but the API is vast. It's huge. And so there's a lot of things that I just kind of want to use , the most common settings for and be able to configure it later.

[00:31:27] Tyler Bell (Memberstack):

I was having a conversation with one of our customers that are developers the other day and he was saying that , the point where it clicked for him is he said that Memberstack, he used our API and before Memberstack, he was using Stripe for all of his projects.

And he said, the point that clicked for him was when he realized that he didn't have to worry about updating his members subscription information in his own database, that he was able to just log in a member through the Memberstack method and was able to respect what Memberstack told him that member had access to.

[00:31:59] John Britton:

I've had to build that kind of stuff myself, it's a huge pain a lot of heavy lifting to keep track of all of that stuff and keep it in sync and inevitably a webhook comes in and your system's down and now you have inconsistent data. That's the nightmare situation. And so if I can just offload that, I really love it.

I wanted to ask you, two final questions. One is, are there any developer tools or, other Yes-code style, things that you've seen that you think would be interesting to the audience or that you're just really in love with right now?

[00:32:30] Tyler Bell (Memberstack):

A tool that I, that we just created an integration for is Make, which was formerly Integramat.

[00:32:36] John Britton:

Tell me about it. I haven't heard of it.

[00:32:38] Tyler Bell (Memberstack):

So, it's a Zapier alternative. I love Zapier, like Zapier is great. I really love their I company and we use Zapier all the time, but, Make takes Zapier and makes it more developer friendly and I think their actual target audience are developers. But they're pretty much saying, like, get all the value and get all the ease of use that you would get from Zapier. But Hey, you want to throw in your own function, you can do that. You want to do more advanced functionality with your own API like you can do that. So it's a lot more open to developers and it's make.com.

[00:33:08] John Britton:

I also found a product recently that's in this kind of space called Pipedream. It's also very similar to Zapier. The thing that I liked about it was I could just write code. I could literally just write some JavaScript and put it in there and it would run it for me. I don't have to manage anything.

And lastly, where should people go if they want to check out Memberstack and what should they do?

[00:33:28] Tyler Bell (Memberstack):

We can be found at memberstack.com and if you're a developer go to "product" in the header and go to "developers," and then from here this is where you can actually get access to our 2.0 Beta product that is primarily built for developers.

[00:33:45] John Britton:

Is that accessible right now? Can people go and use it?

[00:33:48] Tyler Bell (Memberstack):

Yes.

[00:33:48] John Britton:

I've had a little chance to play around with some of this myself, so definitely go check it out. Thanks so much, Tyler. I really appreciate you taking the time to join us. This has been a lot of fun.

[00:33:57] Tyler Bell (Memberstack):

Cool. Yeah. Well, thanks for having me.

[00:33:58] John Britton:

To find out more and stay in the loop with Yes-code, head to yescode.org.