UX study by our product team at Webscope.io, taking on traveling during global pandemic.

UX Case study: Traveling during COVID-19

At the peak of the pandemic when it became clear that we are not going to get rid of it anytime soon, public institutions became burdened by the task of providing daily information about new rules, restrictions, and guidelines for how to cope with it.  

As it usually goes for the public sector, the idea might be well appreciated but the execution often trails behind. Most of the time we have gotten used to it however, with the pandemic affecting our everyday lives it became more and more vexing. 

## Starting point

When European Union 🇪🇺 came up with the idea to unify all the information across the member states we were really thrilled with it. With the *#strongertogether* hashtag they unveil their new portal. Have a look below 👇

![img](https://images.prismic.io/webscopeio/746d00d1-e752-427f-89ce-051f4c51b560_mapa.png?auto=compress,format)With a strong message and a lot of useful information - this had great potential. But after seeing the final result we have decided to put it through our standard design process starting with UX research 🔎.

## UX Research and more

The tool informs about the current coronavirus situation in European countries in one place and keeps the data up-to-date. However, we discovered that users had trouble finding what they were looking for. We realized that the website includes too much information which, in most cases, is not clear.  

In our UX research, we also saw people using the **Travel** ✈️ section the most. They had found this to be the number one reason why they would visit the platform. That is why we decided to focus solely on this use case and to adjust the information presented in this way. 



![img](https://images.prismic.io/webscopeio/afb143bb-b56a-4e59-834c-8fc31e1bdc2b_chart.png?auto=compress,format)



Once we decided on the general use case we had to better understand our target audience, in order to identify what exactly they need from the product. We focused on their goals and observed behavioral  patterns. Based on these we have defined **user personas** to cover their needs. 🙋

We have noticed that users were missing **some functions** in the current platform like **watchdog** 🐶 to be reminded about the actual status of the restrictions, ability to search for routes based on different means of transport or find specific restrictions based on the type of traveler. 





![img](https://images.prismic.io/webscopeio/a45bee4e-d0d7-4baa-a85b-06797520f10c_type.png?auto=compress,format)





After collecting all of this information we have created preliminary **wireframes** to be tested and edited before applying the final design. Once we had this confirmed we were ready to publish our results.

## Solution

Based on all the information we gathered in our UX research we have created a **simple travel app** where you could search for your destination in the EU and find out all the restrictions that apply along the way.✈️ 🌍



![img](https://images.prismic.io/webscopeio/76a73fcf-13c4-4ccc-93e4-2f7a0b736fbd_solution.png?auto=compress,format)





When you are visiting a particular country you want to **know the route - not just the destination.** In this way the user journey follows the most common behavior and saves time spent searching for the information.

For better understanding your route at first glance we decided to implement a simple color palette. We follow the 3 categories already created and used by re-open the EU platform and applied them to our use case.  





![img](https://images.prismic.io/webscopeio/94d5a48f-a60e-4bb7-8875-c7d4b2d7059b_palette.png?auto=compress,format)



We also included most of the features to further complete the user journey. To make sure user has always up to date information we introduced a **watchdog** 🐶 that you ca set-up as in-browser notifications 🔔 ​or via email. 📧 



![img](https://images.prismic.io/webscopeio/9cc0ad9f-d636-4305-a6e1-79e23dcf55aa_watchdog.png?auto=compress,format)



We have tested our concept with users and they loved it. ♥️

Everything is much more clearer comparing to the current platform. From finding your route to getting notified about restrictions, it is faster and much smoother. 

If you want to know more about the process or want to give us feedback check out out [case study on Behance](https://bit.ly/covid-travel-made-simple)

## Implications and outcome

After we have completed and **shared** our version we got really positive feedback within our community. Therefore we have decided to **contact EU representatives** and present them our ideas since as they have put it we are *#strongertogether*.

We have sent them an email with our solution explaining the reasoning and the whole process behind it. After some time after sending the email, we have noticed that the https://reopen.europa.eu/ portal introduced a **new functionality - Travel plan.** 

Here is a little sample of the theor implementation.👇



![img](https://images.prismic.io/webscopeio/fdb24b90-5788-4082-b680-0405bd56dea7_reopen_road.png?auto=compress,format) 



When we forget about UI :smirk: and focus solely on the functional of the feature it accomplished the basic idea we had set out to do. So good job EU for listening to **our feedback!** 🎉

Once the **Travel Plan** has been published we even got a **response email** from the team behind Re-open Europe. They piqued our interest by explaining a few behind-the-scenes obstacles that they have to deal with while building this feature. 


> “Due to the high number of variables, individual situations and fragmentation of rules, it is nearly impossible to offer concise sentences describing the restrictions in place” 



When we hear that something can't be done, we see it as an opportunity for creativity, therefore we agreed to **schedule a call with the EU team** 🇪🇺 to get to the bottom of this and make the portal better for all of us. 

UX Case study: Travel during Covid-19

# Setting up OAuth

In our previous post, we have created a slack command, which needs to be initiated by a user writing `/<name-of-the-command>`.
In the next articles, we will learn how your app can post a message to Slack directly as a reaction to some event.
In our example, we will send a notification about new project report once user reports it. 

For doing this, we need a [Slack Webhook](https://api.slack.com/messaging/webhooks) URL where we will send blocks to be displayed. You can either take them
from Slack Dev UI, but that doesn't really help if you want to distribute your app to users. We will need to generate them programmatically and that is exactly 
where OAuth flow will help us.

In this tutorial we will skip the part where you can manually generate a webhook and send data to it. It's pretty easy and it doesn't really help with a production app.
If you still want to go through this, follow [this tutorial](https://api.slack.com/messaging/webhooks#incoming_webhooks_programmatic).

## What is OAuth

Describing OAuth is out of scope of this article. [This Digial Ocean's tutorial] is probably the one that explains it in the best way.
In their article, they have the following image:

![OAuth Flow](https://assets.digitalocean.com/articles/oauth/abstract_flow.png)

_Source: https://www.digitalocean.com/community/tutorials/an-introduction-to-oauth-2_


## Configuring Your App

In our case, Application is our Slack application and Slack API is the Service API.

1. Go to your _Application Settings_, and define your Redirect URL. This is where Authorization Server (Slack) will send you an Access Token.

![Slack Commmand](https://images.prismic.io/webscopeio/4f97e1f1-0d49-4904-8733-5c72e41cbe11_defining-redirect-url.png?auto=compress,format)

2. In your _Application Settings_ > _Manage Distribution_ you'll find a different ways how your users can install your app.

We'll choose `Embeddable Slack Button` and put it on our homepage. Have a look at [this commit](https://github.com/webscopeio/slack-tutorial/commit/1937e4c74431e0d9176a2a5f2986a093eef9ac43) to see how to do this if you're not experienced with Django.

The important part is to add a new entry to your `urls.py`, create a view that renders HTML and add a Slack button.
Optionally, you can define your `base.html` so that you can re-use the basic styles in other templates e.g. redirect address url that Slack will follow after installing our application.

Right now, we see the following screen at our index.

![Home Page](https://images.prismic.io/webscopeio/4d1535d0-92aa-4657-9304-db2954daa106_homepage+Django+Slack+Tutorial.png?auto=compress,format)

After your users click the button, they'll be redirected to Slack _(Authorization Server)_ (Step 3.) 

![Slack Installation Process](https://images.prismic.io/webscopeio/739e88a3-189c-4162-a64a-3fdfe29a35d2_slack-install-process.png?auto=compress,format)

And Slack will redirect them to your application (Step 4.) with an *Access Token*.

![Non Existing Redirect URL](https://images.prismic.io/webscopeio/6022dd84-aa63-487e-b372-a00172cf6d71_non-existing-redirect-url.png?auto=compress,format)

😮 Our redirect URL doesn't exist, we need it to store an access token. We will use it to talk to Slack later on.

## Setting up Redirect URL

When Slack redirects to our URL. We will have the following data in `request.GET`.

![Non Existing Redirect URL](https://images.prismic.io/webscopeio/f8829f9d-2b6e-4723-af29-b7b459296ae0_oauth-response.png?auto=compress,format)

We will need these data to interact with Slack later on. Let's build models that will persist this information in a database.

Slack Tutorial Part 5 - Incoming Webhooks

# Building a first slack command 🎉

## Setup a Slack application

1. Go to https://api.slack.com/apps and create your app.

2. Go to your app on api.slack.com and create `SLACK_CLIENT_ID`, `SLACK_CLIENT_SECRET` and `SLACK_SIGNING_SECRET` with a correspondent values in `settings.py`.
We will use this later on e.g. when using Incoming Web Hooks.
Secret should be provided as ENV variable and shouldn't be part of the codebase. We will pass it to our process together with a `DATABASE_URL`.

```
SLACK_CLIENT_ID = '5130182099.926289676294'
SLACK_CLIENT_SECRET = os.getenv('SLACK_CLIENT_SECRET')
SLACK_SIGNING_SECRET = os.getenv('SLACK_SIGNING_SECRET')
```

3. Install Python Slack bindings. You'll need them later on.

`pipenv install slackclient`

4. Click on _Slash Commands_ > _Create New Command_

5. We will create command `/teamwork-latest` that will show last 5
   project reports in our app.
   
   You need to fill request URL at this point. However during
   development, you usually can't easily expose your localhost to the
   world so that Slack can access it. Here's where
   [ngrok](https://ngrok.com/) comes handy. It will create a public URL
   and map it to your localhost. Please install it and setup an account.
   By running `ngrok http 8000` it will give you a public URL that will
   route to your local Django instance.
   
   In my case I'll fill out
   `http://slack-tutorial-app.ngrok.io/slack/commands/teamwork-latest/`
   
   
After you've created your command, install your Slack app into your Slack
workspace. Once you run `/teamwork-latest` you should see the following
error.

`/teamwork-latest failed with the error "dispatch_failed"`

That is because we haven't implemented the endpoint yet! So let's do it.

1. Let's create a Slack application

`pipenv run ./manage.py startapp slack_app` and add `slack_app` to
`INSTALLED_APPS`

2. And route all URLs prefixed with `/slack` to our slack app by adding
   `path('slack/', include('slack_app.urls'))` to `urlpatterns` in
   `teamwork/urls.py`
   
3. Configure slack routing. Create `urls.py` in `slack_app` folder.

```python
from django.urls import path

from . import commands

urlpatterns = [
    path('commands/teamwork-latest/', commands.teamwork_latest),
]
```

4. Last, but not least, create a file for commands and a command itself.

`slack/commands.py` 
```python
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt


@csrf_exempt
def teamwork_latest(request):
    return JsonResponse({
        "blocks": [
            {
                "type": "section",
                "text": {
                    "type": "plain_text",
                    "text": "Hello World :tada:.",
                    "emoji": True
                }
            }
        ]
    })
```
   
![Your first slack command](https://images.prismic.io/webscopeio/8563b5af-21f0-4ca4-b030-f56eee5af01f_first-command-output.png?auto=compress,format)

## Generating response

We've returned simple message, but you can build much more. Have a look
at Slack's
[Block Kit Builder](https://api.slack.com/tools/block-kit-builder) at
what UI you can render as a response. The only disadvantage of it is
that it's not Open Source :disappointed_relieved:.

However, in order to return something valuable, we need to generate the
output based on the content in our db. So let's do it 🎉! ... **by
writing tests first** 💪

1. Let's create our expected output in Block Kit Builder e.g. https://api.slack.com/tools/block-kit-builder?mode=message&blocks=%5B%7B%22type%22%3A%22section%22%2C%22text%22%3A%7B%22type%22%3A%22mrkdwn%22%2C%22text%22%3A%22*Project*%3A%20Example%20Project%5Cn%20*Reported%20Hours*%3A%20_8.0h_%5Cn%20*Description*%3A%20I%27ve%20written%20unit-tests%2C%20because%20it%20makes%20the%20whole%20development%20process%20faster%20%3A)%22%7D%7D%2C%7B%22type%22%3A%22divider%22%7D%2C%7B%22type%22%3A%22section%22%2C%22text%22%3A%7B%22type%22%3A%22mrkdwn%22%2C%22text%22%3A%22*Project*%3A%20Important%20Project%5Cn%20*Reported%20Hours*%3A%20_4.0h_%5Cn%20*Description*%3A%20Writing%20React%20components%20and%20making%20Storybook%20cleanup%22%7D%7D%5D


2. In `slack_app` application, create a `blocks` folder where we will store all methods responsible for generating Slack blocks. Inside `blocks`, let's create `slack_commands.py` and `slack_commands_spec.py`.

Our function will accept a Django request object (so that we can later use it to build absolute urls) and expect a list of blocks. Let's create an interface so that we can
create unit-tests.

`slack_commands.py`
```python
from typing import List

def get_teamwork_latest_blocks(request) -> List:
  []
```

`tests_slack_commands.py`
```python
from django.test import RequestFactory, TestCase

from core.models import User
from projects.models import Project, ProjectReport
from .slack_commands import get_teamwork_latest_blocks


class SlackCommandsTests(TestCase):
    maxDiff = None

    def setUp(self):
        self.request_factory = RequestFactory()
        self.request_factory.defaults['SERVER_NAME'] = 'scrumie.com'

        user = User.objects.create(username='Test User')

        project_1 = Project.objects.create(name='Example Project')
        project_2 = Project.objects.create(name='React Project')

        ProjectReport.objects.create(
            project=project_1,
            description="I've written unit-tests, because it makes the whole development process faster :)",
            hours=8.0,
            user=user,
        )

        ProjectReport.objects.create(
            project=project_2,
            description="Writing React components and making Storybook cleanup",
            hours=4.0,
            user=user,
        )

    def test_simple_teamwork_latest_command(self):
        expected_blocks = [
            {
                "type": "section",
                "text": {
                    "type": "mrkdwn",
                    "text": "*Project*: Example Project\n *Reported Hours*: _8.0h_\n *Description*: I've written unit-tests, because it makes the whole development process faster :)"
                }
            },
            {
                "type": "divider"
            },
            {
                "type": "section",
                "text": {
                    "type": "mrkdwn",
                    "text": "*Project*: React Project\n *Reported Hours*: _4.0h_\n *Description*: Writing React components and making Storybook cleanup"
                }
            }
        ]

        request = self.request_factory

        self.assertEqual(expected_blocks, list(get_teamwork_latest_blocks(request)))
```

It's good practise to write a test that fails first and later fix the methods so that the test passes.

You can run tests with `pipenv run ./manage.py test` (this time without passing
`DATABASE_URL`), we don't need to connect to our db for a test run.

> Tip: You can use `find . -name '*.py' | entr pipenv run ./manage.py test` to react to file changes.

The test should fail until you implement the method. Take the challenge and do it yourself or 
...


```python
from itertools import chain
from typing import List

from projects.models import ProjectReport


def get_teamwork_latest_blocks(request, max_items=5) -> List:
  reports = ProjectReport.objects.all().order_by('id')[:max_items]
  if reports:
    return list(chain.from_iterable(
      (
        {
          "type": "section",
          "text": {
            "type": "mrkdwn",
            "text": f"*Project*: {report.project.name}\n *Reported Hours*: _{report.hours}h_\n *Description*: " +
                    report.description
          }
        },
        {
          "type": "divider",
        }
      ) for report in reports
    ))[:-1]

  else:
    return [
      {
        "type": "section",
        "text":{
          "type": "mrkdwn",
          "text": "No Project Reports"
        }
      }
    ]
 ```


Now, please write more tests to try to cover all corner-cases. 

1. What if user has no reports? 
2. What if there is huge number of it? (Slack limits the number of blocks to 50)
3. What if ...


### Let's connect our block function to the actual view

This part is fairly easy, we just replace our mocked blocks with a function we just created.

```python
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt

from slack_app.blocks.slack_commands import get_teamwork_latest_blocks


@csrf_exempt
def teamwork_latest(request):
    return JsonResponse({
        "blocks": get_teamwork_latest_blocks(request)
    })
```

![Slack Commmand](https://images.prismic.io/webscopeio/08459f70-4550-403c-bce2-e7bf1046e9fe_teamwork-latest-empty.png?auto=compress,format)

If you now go to `/admin` and try to create some Project and Project Reports, write `/teamwork-latest` in Slack and you should see the following.

![Slack Commmand](https://images.prismic.io/webscopeio/65bcd8aa-5fd4-42a6-ab54-93547f4bac7e_teamwork-project-reports.png?auto=compress,format)

### Text preview of a message

One last problem with our command is how it's going to be presented in a notifications. Type `/teamwork-latest` and quickly switch your window.
On Mac you'll see the following. _(I'm sorry, but I can't currently test this on other platforms)_.

![Slack Commmand](https://images.prismic.io/webscopeio/10317b9c-844f-4716-be8f-f8e2d30e408c_no-text-message.png?auto=compress,format)

To fix this, just add `text` property to our response.

```python
@csrf_exempt
def teamwork_latest(request):
    return JsonResponse({
        "blocks": get_teamwork_latest_blocks(request),
        "text": "See recent work reports :page_with_curl:"
    })
```

![Slack Commmand](https://images.prismic.io/webscopeio/84d07c01-23fd-4ccf-b994-474086de43b4_text-message.png?auto=compress,format)

🎉 Now you're ready to go ahead and implement your own business logic with Slack Commands.

Slack Tutorial Part 4 - Building a first Slack command

In order to interact with Slack, we need to quickly build some business logic. 
Luckily, that is super easy with Django. We will generate some entities using Django models, and provide an admin interface so that we can create & modify them. One of the reasons I've chosen Django for this tutorial is that we can do this without building a custom UIs.

Our application will allow users to log in and report hours on their projects. They'll also be able to see other user's reports. Simple as that.

We will:

1) Create `Project` model that will hold information about a project
2) `ProjectReport` model that will be used to report hours for each project

## Create reports models

1. `pipenv run ./manage.py startapp projects`

2. Add `projects` string to `INSTALLED_APPS` in your `settings.py`

3. Create `Project` and `ProjectReport` model


`projects/models.py`

```python
from django.contrib.auth import get_user_model
from django.db import models

User = get_user_model()

class Project(models.Model):
    name = models.CharField(max_length=255)
    logo = models.ImageField(null=True, blank=True)

    def __str__(self):
        return self.name


class ProjectReport(models.Model):
    project = models.ForeignKey(Project, on_delete=models.CASCADE)
    description = models.TextField()
    hours = models.FloatField()
    # if we delete a user we don't want to loose the reported hours
    user = models.ForeignKey(User, on_delete=models.PROTECT)

    def __str__(self):
        return f"{self.project.name} - {self.hours} hours - {self.user.username}"
```

and add them to admin interface

`projects/admin.py`
```
from django.contrib import admin

from .models import Project, ProjectReport

admin.site.register(Project)
admin.site.register(ProjectReport)
```

4. `pipenv install Pillow`

We need to do this, because we've added an ImageField..

5. `pipenv run ./manage.py makemigrations` && `pipenv run ./manage.py
  migrate`


`git push` deploy `master` from Heroku.
 
🎉 You can now check our models in the admin interface.

Slack Tutorial Part 3 - Creating backend's business logic

In this part of the tutorial, we will set up a Django application.

You can check out the [repository](https://github.com/webscopeio/slack-tutorial)'s tag: `milestone-1` to see the result. At the end of this tutorial, we will have a Django application setup and deployed on Heroku.

## Setting up Django

1. Install Django with it's CLI (`pip3 install Django`), create new Django project `django-admin startproject teamwork`, `cd teamwork`, initialize git (`git init`)

2. `pipenv install && pipenv shell` Let's activate the pipenv environment. Read more about pipenv here.

3. `pipenv install django gunicorn django-heroku` Install Django and other dependencies. This should modify `Pipenv` and `Pipenv.lock` files.

Your folder structure should now look like this

```
(teamwork) ➜  teamwork git:(master) ✗ tree
.
├── Pipfile
├── Pipfile.lock
├── manage.py
└── teamwork
    ├── __init__.py
    ├── asgi.py
    ├── settings.py
    ├── urls.py
    └── wsgi.py

1 directory, 8 files
```

If you try to run `pipenv run ./manage.py runserver` - you should see the application running at http://127.0.0.1:8000/, please ignore the warning about unapplied migrations.

## Let's configure Heroku!

Heroku is awesome because with it's `django-heroku` package, in just a couple of lines, it will configure the simple Django deployment including the database.

1. Let's create a Heroku project.


a) Create a project

![Alt Text](https://thepracticaldev.s3.amazonaws.com/i/vcpllpyz5bm4oc8svo14.png)

b) Select your preferred region

![Alt Text](https://thepracticaldev.s3.amazonaws.com/i/v79myrxgk1zqfn71q1vg.png)

c) Link with Github

![Alt Text](https://thepracticaldev.s3.amazonaws.com/i/0izkcxhowns4f0p104xq.png)


2. We need to create a `Procfile` in our root directory to let Heroku know how to serve our Django app.

It's content should look like this


```
web: gunicorn teamwork.wsgi
```

Also, add the following import statement to the top of settings.py:

`import django_heroku`

add the following statement to the bottom of settings.py:

```
# Activate Django-Heroku.
django_heroku.settings(locals())
```

Source: https://devcenter.heroku.com/articles/django-app-configuration


3. Push everything to `git` and deploy from Heroku console

![Alt Text](https://thepracticaldev.s3.amazonaws.com/i/1p46r9d0n7mk1l4w4xs9.png)


Congrats, your app should now be deployed! 🎉

![Alt Text](https://thepracticaldev.s3.amazonaws.com/i/vwvb8pll3m1w1e6vibq6.png)

## Setting up a custom user

Quote from an official Django's documentation says

> When you start your project with a custom user model, stop to consider if this is the right choice for your project.

It's absolutely recommended to configure a custom user model at the beginning of your project. You can read more about why [here](https://docs.djangoproject.com/en/3.1/topics/auth/customizing/#specifying-a-custom-user-model).


1. `pipenv run ./manage.py startapp core` - this will create an
   application with name `core`

2. Add `core` string to `INSTALLED_APPS` in your `settings.py`

3. Create CustomUser class in `core/models.py`

    ```python
    from django.contrib.auth.models import AbstractUser


    class User(AbstractUser):
        def __str__(self):
            return self.username
    ```
 
4. And specify `AUTH_USER_MODEL = 'core.User'` in your `settings.py`

## Database configuration

- One more thing though. Heroku automatically created a db and attached it
to your deployment. If you want to work with this database remotely, you
need to pass `DATABASE_URL` to your process (or differently set it for
Django).

- Open Heroku, go to _Settings_ > _Config Vars_ > _Reveal Config Vars_

- You'll find a Postgres URL as `DATABASE_URL`. You can copy this value
and pass it to your commands like this `DATABASE_URL=<value> pipenv
./manage.py <cmd>` or optionally set it in your environment.

- Now, make sure you apply migrations to this database.

- `DATABASE_URL="postgres://...." pipenv run ./manage.py makemigrations && pipenv run ./manage.py migrate`

- **For the sake of readability, we will omit passing `DATABASE_URL` in
this tutorial and expect you to pass the correct value.**




Slack Tutorial Part 2 - Setting up Django and Heroku deployment v2

In this series of articles, I'd like to make a step-by-step guide on how
to create your Slack application. Ever since I discovered Slack and
it's API I knew this is the way how to automate an enormous number of
tasks within our company. I've played around with it and now it's time
to share it with others.

## What do you need to know?

1. Basic understanding of Python, ideally Django. However, I'll try to explain the core concepts, so I hope you'll be able to follow up with any technology like Flask or even different languages like Node.js, Rails or others.
2. Knowledge of git
3. How Slack works
4. (Optionally) go through this very quickly before we start https://api.slack.com/start/planning

## Why did I choose Django? 

Python is usually the language used to teach students how to code as
well as used by professionals. I wanted this course to be also useful
for people who started to code just recently. It's true that Django is a bit complex, but I'll try to explain
all the changes and provide multiple checkpoints in a Github repository.

Django combined with Heroku will provide us with a nice way how to
persist data and with pretty easy routing. It's quite opinionated, so I
hope it will be easy for people to find information on how to solve
specific problems. With its automatic Admin interface, it'll be easy to
mock users & various data structures.

## How is this tutorial structured? 

In Part 1, we will explain the basic
concepts and briefly describe the API. We will basically show you what
you can do with your Slack Application. In Part 2, we will set up a
repository, Django project, reverse proxy that we will need for local
development & solve the automatic deployment of our app from Github
thanks to Heroku ❤️. In Part 3, we send the first interaction to
Slack. In Part 4, we will implement various interactions that we
described in Part 1.

## What is the final Django Application we will create about?

It's a simplified version of our startup [Scrumie.com](https://scrumie.com) Our application will be
capable of the following:

1. Users will create reports about their work and those reports will be reposted to a certain
channel.
2. We will allow them to create those reports from Slack
3. We will remind them to write them in case they'll forget to do so. 

Blog

UX Case study: Travel during Covid-19

Slack Tutorial Part 5 - Incoming Webhooks

Slack Tutorial Part 4 - Building a first Slack command

Slack Tutorial Part 3 - Creating backend's business logic

Slack Tutorial Part 2 - Setting up Django and Heroku deployment v2

Slack application tutorial in Django - Introduction

Let’s stay connected