SCILL challenges are a simple, yet effective method of retaining users in your platform by offering them something to do and to rewarding them for doing so. In games, sports and even business, challenges offer an interesting and engrossing, yet inconspicuous way for users to leave their comfort zone.

While challenges are a simple concept, in practice it’s not easy to implement them. You need to track massive amounts of data, must process it, and in most cases GDPR compliances are mandatory.

Leverage SCILL’s easy-to-use backends to send event data, build challenges visually with our challenge creator in the Admin Panel and implement them in a couple of hours into your existing application or game.

Challenges implementation in SCILL Play Desktop App

Challenges implementation in SCILL Play Desktop App

Key capabilities

Admin Panel

Our Admin Panel allows you to set up multi-language challenges quickly and our query browser makes it very easy to setup even the most complex challenges. Use the Admin Panel to analyse usage patterns.


Challenges can be anything you want as long as you can express the goal as a single number. Challenges can be very simple or very complex. This is up to you and your application. Whatever it is, SCILL challenges has you covered.

Realtime updates

Users need to see in real time if they made progress in their challenges. SCILL offers Websockets and Webhooks to quickly implement real time updates into your game or app. In our SDKs it’s just one function call.

Send events

Use our SDKs to send events that trigger challenge progress updates.

Designed to scale

Create as many challenges as you like and send as many events as you like. We operate a world-wide net of nodes. Traffic is automatically routes to the best available location.

How does it work?

The basic concept of a challenge is pretty simple: You set a goal and ask the user to reach that goal within a certain period. Goals must be measurable with one simple integer. Every active challenge has a current state which is also an integer. A simple challenge for example is: “Invite 5 other users”. The goal here is 5, the current state will be 0 when the challenge is activated. After the user invited one other user an event is sent to SCILL. SCILL will process that event and increases the counter of the current state by 1. SCILL cloud will then notify your backend by calling a Webhook (if defined) and will notify any connected clients of this user to reflect this change in the user interface in real time.

Implementation Path

1Create Challenges

Create challenges in our Admin Panel

2Integrate SDK

Integrate our SDK into your app or game. We offer SDKs for all major platforms

3Add User Interface

Implement a user interface to show challenges to your users within your app or game. Our SDKs offer simple to use methods of getting user specific data and update them in real time. We also provide example user interface for major platforms.

4Send events

Use our SDKs to send events that trigger challenge progress updates.

5Reward users

If users achieve a challenge you should give them a reward like a free item, a badge or an achievement.


Challenges are a complex product as there are many different possibilities to set them up. More info can be found in the API documentation on challenges and the guides. However, the most important features and rules are listed here for completion:

One event, multiple challenges

One single event can drive multiple challenges. Think about these two challenges:

In this case, if the player completes a round, an event is sent like this:

    "event_name": "finish-round",
    "event_type": "single",
    "session_id": "__SESSION_ID__",
    "meta_data": {
        "round_id": 0,
        "health": 100

This event will track both challenges and both challenges will increment the counter by 1. If health is just 80 for example, then only the second challenge will progress by 1.

If you don’t want this behavior, you need to add a property (in this case for example round_type) that you can set in the meta_data object.

Automatic time management

Challenges have a complex lifecycle that can be either managed manually or automatically by the SCILL backend.

Automatic challenges follow these basic rules:

  • Are activated automatically once:
  • Will be reset (i.e. put in the unlock state) at a time and time-zone that you specify:
    • every day (challenge_duration_time is number of minutes to next reset time) or
    • every week (challenge_duration_time is number of minutes to next reset time) or
    • every month (challenge_duration_time is number of minutes to next reset time) or
    • never - in this case, the challenge has a challenge_duration_time of -1.
  • Once completed the challenge will automatically by claimed and then set into the finished state where it stays until the reset is executed.

Manual time management

In this case, you use our SDK or REST-APIs to drive each challenge to the life cycle.

  • Challenges need to be manually unlocked and then activated.
  • Challenges have a fixed, specified duration
  • If challenge is won (i.e. counter >= goal within the duration) it will be in state unclaimed (forever) and must be claimed manually by the user.
  • If challenge is lost (i.e. counter < goal after duration exceeded) it will be
    • Hidden from the user in subsequent requests if repeatable is set to false.
    • Reset to unlock state if the challenge is repeatable
  • Once a unclaimed challenge is manually claimed via REST-API it will be
    • Hidden from the user in subsequent requests if repeatable is set to false.
    • Reset to unlock state if the challenge is repeatable

Next Steps