We now have a real Partner program

We've been thinking about working with creators around Peliku for a while, but we didn't want the system to stop at "here's a promo code".

A real partnership has more going on around it. There's a contract, a period during which the partnership is active, a commission rate, one or more promotional codes and eventually commissions and payments to keep track of.

Peliku 1.4 now has a system built around that whole relationship.

A partner can have:

• A contract with a defined period
• A commission rate
• One or more promotional codes
• A dedicated Partner space
• Commission tracking
• A payment history
• Statistics about the users they brought to Peliku

The important part for us was building something we can actually use with creators over time instead of creating a temporary system we'd have to replace as soon as the program started growing.

The first partner stays the acquisition partner

One of the first questions we had to answer was what happens if someone uses more than one promotional code over time.

Imagine a creator introduces someone to Peliku and that person uses their code. A few months later, the same user finds another promotion and uses a different code.

We don't think that should erase the creator who originally brought them to Peliku.

So we've implemented first-touch attribution.

Comment ça marche

The first time someone uses a partner code, that partner becomes their acquisition partner.

If the user later uses another promotional code, they can still benefit from that promotion when it's valid, but their original acquisition partner doesn't change.

In other words, the promotion and the partner attribution are two different things.

A user can benefit from a later promotion without changing who originally introduced them to Peliku.

Partners now have their own statistics

If we're asking creators to work with us, we don't want their only feedback to be a code and a vague promise that we'll tell them how it's going.

Partners now have a dedicated Statistics area where they can follow what is happening around their partnership.

They can see things such as:

• Code uses
• Users currently in trial
• Customers acquired
• Active paid subscriptions
• Customers who later cancelled
• Users who didn't convert
• Conversion rate

There's also a graph for following code usage and newly acquired customers over time, with monthly and yearly views.

We deliberately don't show individual users

We want partners to understand whether the partnership is working. They don't need to know who each individual user is.

So the statistics are aggregated.

Partners don't receive a list of names, emails or individual accounts behind those numbers.

We also hide some very low-volume data when showing it could make individual users easier to identify.

Commissions are based on payments Peliku actually receives

We also wanted commission tracking to be connected to real payments rather than estimates.

When an eligible payment is received, Peliku can calculate the commission using the information attached to the partnership.

The calculation takes into account:

• The partner attributed to the customer
• The active contract
• The commission rate defined in that contract
• The amount actually eligible for commission

This means the partner's commission follows what actually happened with the subscription instead of being based only on a code use or signup.

Partners can follow commissions and payments

The Partner space includes commission tracking and a history of payments that have been made.

We chose to present commission details by week rather than exposing every individual customer payment.

That gives partners enough detail to understand their earnings while keeping individual customer activity private.

Partners can receive Peliku Team for free

We also wanted active partners to be able to use Peliku properly while they're working with us.

An eligible partner can now receive Peliku Team free for the duration of their contract.

And we didn't build a separate "partner version" of Team.

It's a real Peliku Team subscription, which means the partner gets the same Team features as a normal Team subscriber.

No card and no surprise charge at the end

The partner benefit is:

• 100% free during the partnership
• Available without adding a bank card
• Active for the duration of the contract
• Stopped automatically when the partnership ends
• Unable to turn itself into a paid subscription by accident

While Team is being provided through the partnership, switching to Creator or Enterprise is disabled too.

We wanted to avoid ending up with a free partner subscription and a normal paid subscription trying to manage the same account at the same time.

Privacy was part of the Partner program from the start

Building statistics around referrals creates an obvious question: how much information should the partner actually be able to see?

For us, the answer is pretty clear. Enough to understand the partnership, but not the personal information of Peliku users.

Partners never get access to:

• User names
• Email addresses
• User IDs
• Stripe information
• Individual subscription details
• Individual payment amounts

The statistics they see are aggregated, and low-volume information can be hidden when necessary.

Deleting an account also stops ongoing user tracking

If a Peliku user deletes their account, the link that would allow their future account state to continue being followed is removed too.

Financial history that needs to remain for accounting and commission records can still be preserved, but it doesn't mean the partner gets continuing access to information about the deleted user.

---

The synchronized teleprompter is more stable

Peliku 1.4 isn't only about partnerships.

We've also continued working on Shooting mode, especially the synchronized teleprompter we introduced for multi-device filming.

In some situations, the follower device could make a sudden jump forward or backwards while following the controller.

This was especially noticeable on some shorter segments.

We've changed the way synchronization is handled

The follower now takes more context into account before reacting to synchronization information.

That includes things like:

• How old the received information is
• Network latency
• Anchors that have already been processed
• The real size of the movement on screen

The result is a much more stable follower, with fewer sudden backwards or forwards jumps during synchronized filming.

It's one of those fixes that sounds very technical when we explain what changed, but the goal is simple: the person reading the prompter shouldn't notice the synchronization working.

Scripts and notes no longer get blocked by unrelated unsaved changes

We also fixed a frustrating navigation problem.

Peliku protects unsaved changes so we don't accidentally leave something we're editing and lose the work.

The problem was that this protection could sometimes be too broad.

A modification somewhere else in the content could prevent us from selecting another script or note, even when that script or note wasn't the thing with unsaved changes.

We've isolated that protection more carefully.

Unsaved work is still protected, but a change in another part of the project no longer blocks navigation between scripts and notes when it doesn't need to.

Stripe subscriptions are more reliable

We've also spent a lot of time on something that isn't very visible until it goes wrong: subscriptions.

Billing has a lot of edge cases. Trials end. People subscribe again. Promotional codes are used. Stripe's data formats evolve. Subscription states can change at different moments.

Peliku 1.4 includes several fixes and safeguards around those situations.

Re-subscribing after a finished trial works better

We corrected cases where someone returning after the end of a trial could have problems starting a new paid subscription.

We've improved compatibility with Stripe data

The billing system now handles newer Stripe data formats more reliably instead of depending too heavily on one specific response structure.

Invoice periods are more accurate

We've corrected the subscription periods displayed on invoices so the dates better reflect the real billing period.

Payment receipts identify the plan more reliably

We've improved the way Peliku determines which plan belongs to a payment, which makes billing information and emails more dependable.

Promotional subscriptions are handled more carefully

We've improved the way subscriptions using promotional codes are created and maintained.

In particular, discounts are preserved correctly when someone subscribes during a trial instead of being lost when the subscription moves into its paid period.

We've added more safeguards against duplicate subscriptions

We've also strengthened the checks around subscription creation and synchronization between Stripe and Peliku.

The goal is to reduce the risk of someone ending up with duplicate subscriptions or Peliku and Stripe disagreeing about the real state of the account.

Billing emails understand partner benefits too

Adding free Team subscriptions for partners created another situation we needed to handle properly.

A normal subscription and a Team plan offered through a partnership might technically share parts of the same subscription system, but they don't mean the same thing to the person receiving the email.

So we've updated the billing emails to understand that difference.

If Team is being provided for free through an active partnership, Peliku shouldn't send an email that makes it sound like a normal paid subscription is being cancelled or that a payment is about to be taken.

The emails now distinguish more clearly between standard subscriptions and Team access provided as a partner benefit.

It's a small detail from the outside, but an important one. Billing emails are already the kind of emails people pay attention to. We definitely don't want them creating confusion when there's actually nothing to pay.

---

Peliku 1.4 adds a whole new side to the app

The Partner program is probably the biggest part of this release because it isn't just one new page or one new setting.

We needed the whole journey to make sense from the moment someone discovers Peliku through a creator to the moment a commission is eventually generated.

And we wanted every part of that chain to stay connected without giving partners access to information about individual Peliku users.

That's why attribution, statistics, commissions, payments and privacy were built together instead of adding them one by one later.

Why we're building the Partner program this way

We want to work with creators who genuinely use Peliku and can talk about it in their own way.

If someone introduces their audience to the app and some of those people eventually become customers, we want to be able to follow that properly and compensate the creator according to the partnership we've agreed on.

At the same time, we don't want that relationship to depend on giving partners access to customer information they don't need.

So the system is built around attribution and aggregated results rather than individual user tracking from the partner's point of view.

It's a more complicated system than simply creating a discount code, but it's also much closer to the kind of Partner program we actually want to run.

And alongside that, we're still fixing the everyday stuff

A big new feature doesn't mean we've stopped looking at the rest of Peliku.

The teleprompter synchronization fix, script and note navigation, Stripe improvements and billing email changes all came from the same place: things we noticed could be more reliable or less confusing.

Some updates completely change what Peliku can do. Others just remove a frustrating little moment from something that already exists.

We need both.

---

What's coming next?

Peliku 1.4 gives us the foundation we needed to start working with real creator partners while keeping the system clear enough for partners and private enough for users.

Now we're continuing to work on some of the bigger pieces that will connect Peliku to more of the content production process.

Deeper social platform connections

Social platforms are becoming a much bigger part of what we're building next.

We want Peliku to connect directly to the accounts we use for publishing instead of the workflow stopping just before the content leaves the app.

Publishing directly from Peliku

The goal is to be able to prepare content in Peliku and publish it to supported platforms such as YouTube, Instagram and TikTok without repeating the same work separately on every platform.

There's a lot to handle properly here because each platform has its own rules, fields and publishing process, but that's exactly the kind of repetitive work we want Peliku to make easier.

Social statistics inside Peliku

Once content is published, we also want the results to come back into the project.

That means being able to follow useful publication statistics without completely disconnecting them from the video that created them.

Built-in file storage

We're also continuing to prepare file storage directly inside Peliku.

We currently still rely on external storage services for parts of the production workflow. We want creators to have the option to keep project files directly with the content too.

Peliku 1.4 is another piece of the bigger picture

A few versions ago, most of our work was focused on organizing the production itself.

That's still at the heart of Peliku, but the app is starting to connect more of the things happening around that production too.

The Partner program is a good example. It isn't directly about writing a script or filming a video, but it's part of the ecosystem around creators and the way we want Peliku to grow.

At the same time, we're still paying attention to the smaller things inside the app. The teleprompter needs to stay smooth. Scripts and notes need to be easy to navigate. And if someone pays for Peliku, the subscription system needs to behave exactly the way they expect it to.

That's really what this release is about for us: adding something completely new without forgetting the reliability of what is already there.