In this article, let's take a look at some of the most significant changes in Meilisearch's latest update. You can read [the full changelog on GitHub](https://github.com/meilisearch/meilisearch/releases/tag/v0.30.0), but we’ll go over the main ones in this article.

Zero downtime index deployment
------------------------------

Syncing your database changes with your Meilisearch index results in downtime. You cannot afford a “broken” search: user experience is paramount. You’ve come up with some workaround, but it takes time and resources. There must be a simpler way to handle this, right?

v0.30 introduces index swapping. You can now deploy a new index version with zero downtime!

To synchronize the changes between your primary database and your Meilisearch index  —`indexA`— in production, you just need to take the following steps:

*   Step 1: Create a new version of the index —`indexA_new`— containing all those changes
*   Step 2: Swap indexes, which means you replace the documents, settings, and task history of `indexA` with those of `indexA_new`. This is the request you need to send for the magic to happen:

```bash
curl \
  -X POST 'http://localhost:7700/swap-indexes'\
  -H 'Content-Type: application/json' \
  --data-binary '[
      { "indexes": ["indexA", "indexA_new"] }
  ]'
```

⏲️ Wait for the task’ status to update to `succeeded`...

🎉 Tada! Your changes are now in production! Your users are still searching in `indexA`, but it holds the data of `indexA_new` now, and `indexA_new` holds the data of `indexA`.

New features: task cancelation and deletion
-------------------------------------------

v0.30 gives you more control over asynchronous operations: you can now cancel tasks and delete your task history.

### Task cancelation

The inability to cancel tasks has been one of the recurring problems users have raised over time. Not being able to interrupt tasks enqueued by mistake or taking too long to process can be very frustrating.

With v0.30, this problem is now a thing of the past. With the new API route `/tasks/cancel`, you can cancel enqueued or processing tasks based on their:

*   `uid`
*   `status`
*   `type`
*   `indexUid`
*   the date they were enqueued or started (`beforeEnqueuedAt`, `afterEnqueuedAt`, `beforeStartedAt`, `afterStartedAt`)

You can learn more about tasks in our [documentation](https://docs.meilisearch.com/learn/advanced/asynchronous_operations.html#understanding-tasks).

To cancel all enqueued tasks that add or update documents to an index, you should send the following request:

```bash
curl \
  -X POST 'http://localhost:7700/tasks/cancel?statuses=enqueued&types=documentAdditionOrUpdate’

```

### Task deletion

Succeeded or failed —and now canceled— task information can take up much-needed disk space in instances with a large number of asynchronous operations. Clean up finished tasks with the new `DELETE /tasks` endpoint.

Just as for task cancelation, task deletion can be done based on the tasks’:

*   `uid`
*   `status`
*   `type`
*   `indexUid`
*   the date they were enqueued or started (`beforeEnqueuedAt`, `afterEnqueuedAt`, `beforeStartedAt`, `afterStartedAt`)

But you can also delete them based on the date they finished processing and what task canceled them:

*   `beforeFinishedAt`
*   `afterFinishedAt`
*   `canceledBy`

The following request deletes all tasks processed before October 11, 2020, at 11:49:53 am.

```bash
curl \
  -X DELETE 'http://localhost:7700/tasks?beforeFinishedAt=2020-10-11T11:49:53.000Z'

```

New feature: configuration file support
---------------------------------------

Thanks to our dear contributor [mlemesle](https://github.com/mlemesle/), a new way of configuring your Meilisearch instance has entered the chat. Along with environment variables and CLI options, you can use a configuration file 🥳

Configuration files can be easily shared and versioned. They allow you to manage all configuration options in one place and give an overall view at a glance.

To do so, set the desired instance options in a single  `.toml`  file:

```toml
env = "production"
master_key = "YOUR_MASTER_KEY_VALUE"

```

You can use the `--config-file-path` CLI option or the `MEILI_CONFIG_FILE_PATH` environment variable to specify a configuration file. Otherwise, Meilisearch will use the file `./config.toml` in the working directory as the default configuration file. You can download a default configuration file with the following command:

```json
curl https://raw.githubusercontent.com/meilisearch/meilisearch/main/config.toml > config.toml
```
<Callout>
  Please note that specifying the `config-file-path` key in the configuration file will throw an error.
</Callout>

If no configuration file is provided, the `Config file path` is set to `none`.

Improvement: search result pagination
-------------------------------------

v0.30 introduces a numbered pagination mode for users who need pagination interfaces.

Up to v0.29, when using the search endpoint, Meilisearch only returned `estimatedTotalHits`, an estimate of how many documents matched the query. For this reason, creating interfaces with a page selector was not recommended.

You can now use the new search parameters `page` or `hitsPerPage` to get the exhaustive number of hits and the total number of pages for a query.

```bash
curl \
  -X POST 'http://localhost:7700/indexes/movies/search' \
  -H 'Content-Type: application/json' \
  --data-binary '{ "q": "american ninja", "page": 1 }'

```

The above request will fetch the first page of results for the given query and will return the following response:

```JSON
{
  "hits": [
        // … 20 hits
    ],
  "query": "american ninja",
  "processingTimeMs": 2,
  "hitsPerPage": 20,
  "page": 1,
  "totalPages": 49,
  "totalHits": 966
}

```

As you can see, it returns the exhaustive number of search results (`totalHits`) and the number of search results pages (`totalPages`), which allows you to create numbered pagination interfaces easily.

  
👉 Note that `totalHits` and `totalPages` are calculated based on the [pagination.maxTotalHits index setting](https://www.meilisearch.com/docs/reference/api/settings#pagination).

Breaking changes
----------------

### Field rename

When [deleting documents by batch](https://docs.meilisearch.com/reference/api/documents.html#delete-documents-by-batch), the corresponding task object contains a field with the number of document ids received. This field, previously called `receivedDocumentIds`, has been renamed to `providedIds`.

### New error

In cases where users try accessing the `/keys` route without setting a master key, Meilisearch now throws a more helpful error  `missing_master_key`:

```JSON
{
    "message": "Meilisearch is running without a master key. To access this API endpoint, you must have set a master key at launch.",
    "code": "missing_master_key",
    "type": "auth",
    "link": "https://docs.meilisearch.com/errors#missing_master_key"
}
```

### Task filter and error naming

To keep naming consistent with the value they can have, we have pluralized the query parameters used to filter tasks:

*   `indexUid` becomes `indexUids`
*   `type` becomes  `types`
*   `status` becomes  `statuses`

We have also renamed the following error codes:

*   `invalid_task_type` to `invalid_task_types_filter`
*   `invalid_task_status` to `invalid_task_statuses_filter`

Hacktoberfest contributions
---------------------------

We are infinitely grateful for all the contributions we received during Hacktoberfest. Most of the changes mentioned above were from these contributions, and we would like to highlight two more. We would not have released them in this version if it were not for our contributors.

*   Support for compressed API requests (Gzip, Brotli, Zlib) by [@mou](https://github.com/mou)
*   Apple Silicon binaries are available thanks to [@jeertmans](https://github.com/jeertmans)

Other changes
-------------

*   Meilisearch has been binding by default to `127.0.0.1:7700` , which is an IPv4 address. In order to make Meilisearch reachable through both [IPv4](https://en.wikipedia.org/wiki/IPv4) (`127.0.0.1:7700`) and [IPv6](https://en.wikipedia.org/wiki/IPv6) (`[::1]:7700`) addresses, we have changed the default address to `localhost:7700`.
*   All task objects now contain the `canceledBy` and `error` fields
*   New [task filters](https://docs.meilisearch.com/learn/advanced/asynchronous_operations.html#filtering-tasks) are available for the `GET /tasks` endpoint:
    *   `uids`
    *   `beforeEnqueuedAt` / `afterEnqueuedAt`
    *   `beforeStartedAt` / `afterStartedAt`
    *   `beforeFinishedAt` / `afterFinishedAt`
    *   `canceledBy`
*   We have introduced a new task type: `snapshotCreation`. Snapshots tasks are now visible in [the task list](https://docs.meilisearch.com/reference/api/tasks.html#get-tasks)
*   The indexing speed has been significantly increased
*   We have reduced both the size of the Meilisearch binary and the size the Meilisearch instance takes up in disk space
*   All instance options now have their corresponding environment variable. Some related to the snapshot and dump features were missing

A big thank you to all our contributors! This project wouldn't have gotten very far without your help 🙏

And that’s it for v0.30! Remember to check the [changelog](https://github.com/meilisearch/meilisearch/releases/tag/v0.30.0) for the full release notes.

What's new in v0.30

Time to close the door behind Hacktoberfest 2022! What an event it was, the time has come to sum up our learnings for this year to better prepare for the future.

For the third time in a row, everyone at Meilisearch was very excited to be participating in Hacktoberferst, probably one of the most popular celebrations of the open-source community online.

We were very grateful for everyone support and contributions throughout the month, please find below the recap we’ve shared internally.

Our teams really enjoyed taking part into the event, leaving us no choice but to go for one more round next year: Hacktoberfest 2023, here we come!

Here, you can find the slides of the presentation with a few comments for context:

![](https://unable-actionable-car.media.strapiapp.com/External_Hacktoberfest_2022_A_recap_636027ab45.jpg)

![](https://unable-actionable-car.media.strapiapp.com/External_Hacktoberfest_2022_A_recap_3_082f4c1b7d.jpg)

![](https://unable-actionable-car.media.strapiapp.com/External_Hacktoberfest_2022_A_recap_4_54734eb823.jpg)

![](https://unable-actionable-car.media.strapiapp.com/External_Hacktoberfest_2022_A_recap_5_f0c74dca0b.jpg)

It’s important to keep in mind the way we count our PRs might be slightly different from the official counting. In the following graph, we counted any PR merged during October, and we included the PRs that were validated but not merged in time on October 31st. Some PRs were open before October 1st but still benefited from the “Hacktoberfest approved” tag since they were completed during October.

![](https://unable-actionable-car.media.strapiapp.com/External_Hacktoberfest_2022_A_recap_6_cbd60a838b.jpg)

![](https://unable-actionable-car.media.strapiapp.com/External_Hacktoberfest_2022_A_recap_7_7b0c2029be.jpg)

![](https://unable-actionable-car.media.strapiapp.com/External_Hacktoberfest_2022_A_recap_8_d35b08263e.jpg)

![](https://unable-actionable-car.media.strapiapp.com/External_Hacktoberfest_2022_A_recap_9_4c4e155893.jpg)

![](https://unable-actionable-car.media.strapiapp.com/External_Hacktoberfest_2022_A_recap_10_1_78e13c206c.jpg)

We were truly blown away by the number of contributions we received this year! We didn’t quite reach our fourth goal, but we set it as such, knowing it was definitely going to be a challenge. At the same time, we were thrilled to see we weren’t that far away from it!  
  
These objectives being hit isn’t just an ego boost for us. It also translates directly into monetary donations for various organizations we’ve selected before the start of the event. The following organizations were selected on the basis of causes that are important to us. We also tried to find some groups that were geographically close to some of the employees of Meilisearch. This second criterion is because we wish to establish a stronger link with the organizations we donate to. We’d love to remain in touch with them and maybe see how our donation- by extension yours!- has potentially improved things for them.  
  
As we mentioned briefly, these donations wouldn’t have been achievable without your support and contributions throughout the whole month of October! We wish to extend a big thank you to everyone for that.

![](https://unable-actionable-car.media.strapiapp.com/External_Hacktoberfest_2022_A_recap_11_1_8804545d22.jpg)

![](https://unable-actionable-car.media.strapiapp.com/External_Hacktoberfest_2022_A_recap_12_a474cd83ac.jpg)

![](https://unable-actionable-car.media.strapiapp.com/External_Hacktoberfest_2022_A_recap_13_625ef09d3b.jpg)

![](https://unable-actionable-car.media.strapiapp.com/External_Hacktoberfest_2022_A_recap_14_00a1b66b56.jpg)

![](https://unable-actionable-car.media.strapiapp.com/External_Hacktoberfest_2022_A_recap_15_1_ba4bae4f61.jpg)

![](https://unable-actionable-car.media.strapiapp.com/External_Hacktoberfest_2022_A_recap_18_2_c65de291a9.jpg)

![](https://unable-actionable-car.media.strapiapp.com/External_Hacktoberfest_2022_A_recap_19_70512c60c4.jpg)

![](https://unable-actionable-car.media.strapiapp.com/External_Hacktoberfest_2022_A_recap_20_ad1a2df74e.jpg)

Hacktoberfest 2022 recap

<Callout>
  This post was originally published in May 2020 by guest author [Riccardo Giorato](/blog/author/riccardo/)t the time, Meilisearch was on v0.09. It has been updated by [Carolina Ferreira](/blog/author/carolina/)o work with Meilisearch v1. You can find the first version of the post on [GitHub](https://github.com/meilisearch/tutorials/tree/main/src/react-decathlon/original-tutorial/original-tutorial.md).
</Callout>

Introduction
------------

In this tutorial, you'll learn how to easily create a search-based web app with instant and reliable results thanks to the power of Meilisearch.

We will cover the basic steps to add our data to Meilisearch, create a custom front-end search, and move on to customization at the end.

For this tutorial, we are going to create an instant search experience for a sports brand. Here is a preview of what you will be building:

![Searching for multiple items on the decathlon demo using Meilisearch](https://unable-actionable-car.media.strapiapp.com/decathlon_d14c32764d.gif)

Prerequisites
-------------

Before getting started, ensure that you have [Node.js](https://nodejs.org/en/) >= 18 installed on your machine.

You can follow this tutorial and write the code as you go through the steps, using this [GitHub project](https://github.com/meilisearch/tutorials/tree/main/src/react-decathlon).

Finally, this tutorial assumes that you are already familiar with React. If that is not the case, you can check the [React Documentation](https://reactjs.org/docs/getting-started.html) to learn more.

Getting Started
---------------

### Clone the repository

Clone the GitHub repository using the following command:

```json
git clone https://github.com/meilisearch/tutorials.git
cd src/react-decathlon

```

### Run a new Docker image

If you cloned the repository to set up the Meilisearch instance, just execute the following commands inside the main folder:

```json
npm install
npm run setup_meili
```

If you didn't clone the repository and want to launch Meilisearch using Docker, execute this command:

```json
docker run -it --rm \
    -p 7700:7700 \
    -e MEILI_ENV='development' \
    -v $(pwd)/meili_data:/meili_data \
    getmeili/meilisearch:v1.0
```
<Callout>
  By default, Meilisearch's API is unprotected. You will need a master key in production. You can learn more about it in our [documentation](https://docs.meilisearch.com/learn/security/master_api_keys.html).
</Callout>

You can check if Meilisearch is running by visiting: [http://localhost:7700/](http://localhost:7700/)

Want to avoid a local installation? To quickly create a best-in-class search experience, we offer the convenience of [Meilisearch Cloud](https://cloud.meilisearch.com/?ref=blog.meilisearch.com), a hosted and fully‑managed version of Meilisearch. There's a free 14-day trial, no credit card required 😉

### Create an index in Meilisearch

An index is an entity where documents are stored, like an array of objects with some specific settings attached to it, and a unique [primary key](https://docs.meilisearch.com/learn/core_concepts/primary_key.html#primary-key).

Each document indexed must have a primary field, a special field that must be present in all documents. This field holds the unique value of the document: its id.

Meilisearch can infer the primary key from your dataset, provided that it contains the `id` substring. You can also set it explicitly.

Below is a sample document to add to Meilisearch.

```javascript
{
  "id": 100013768717,
  "name": "Fitness Foldable Shoe Bag",
  "url": "https://www.decathlon.com/products/gym-foldable-shoe-bag",
  "vendor": "Domyos",
  "category": "Sport bag",
  "tags": [
    "Artistic Gymnastics",
    "Boy's",
    "CARDIO_FITNESS_ACCESSORIES",
    "CARDIO_FITNESS_BAGS",
    "CODE_R3: 11782"
  ],
  "images": "https://cdn.shopify.com/s/files/1/1330/6287/products/sac_20a_20chaussure_20kaki_20_7C_20001_20_7C_20PSHOT_20_490180e6-44e4-4340-8e3d-c29eb70c6ac8.jpg?v=1584683232",
  "creation_date": "2020-04-03T15:58:48-07:00",
  "price": "2.49"
}

```

You can easily create this index with a REST client like [Postman](https://www.postman.com/), but in this tutorial, we will use the [Meilisearch Javascript SDK](https://github.com/meilisearch/meilisearch-js/) to do it directly from Node.js.

```javascript
const { MeiliSearch } = require('meilisearch')

;(async () => {
  try {
    const config = {
      host: 'http://localhost:7700'
    };

    const meili = new MeiliSearch(config);
    
    await meili.createIndex('decathlon'); 
    
    // or you can set the primary key explicitly: 
    // await meili.createIndex({ uid: "decathlon", primaryKey: "id" });
        
  } catch (e) {
    console.error(e);
    console.log("Meili error: ", e.message);
  }
})();

```

You can read more about the properties of indexes in the [Meilisearch documentation](https://docs.meilisearch.com/learn/core_concepts/indexes.html).

### Index documents

Meilisearch receives documents in JSON format and stores them for searching purposes. These documents are composed of fields that can hold any type of data. Meilisearch also accepts datasets in the following formats: NDJSON and CSV. You can read more about the format in the [documentation](https://docs.meilisearch.com/learn/core_concepts/documents.html#upload).

For this tutorial, you can download this dataset full of sportswear items: [**decathlon.json**](https://github.com/meilisearch/tutorials/tree/main/src/react-decathlon/backend/decathlon.json)

Use the following script to upload all the objects from this JSON file to Meilisearch. Remember to change the path to your JSON file before running it!

```javascript
const { MeiliSearch } = require('meilisearch')

;(async () => {
  try {
    const config = {
      host: 'http://localhost:7700'
    };

    const meili = new MeiliSearch(config);

    const decathlon = require("../decathlon.json"); // path to json file

    const index = meili.index("decathlon");
    
    await index.addDocuments(decathlon);
        
  } catch (e) {
    console.error(e);
    console.log("Meili error: ", e.message);
  }
})();

```

Prepare the React app
---------------------

We'll need a standard React app. You can use the project you cloned before in the [Getting started](/blog/instant-search-react-app/#getting-started)ection.

If you prefer to start from an empty app, you can create your own using [Create React App](https://create-react-app.dev/) with the command below. You can name the application however you desire.

```json
npx create-react-app meili_react_demo
cd meili_react_demo

```

### Include Tailwind CSS

To speed up the styling process, add [Tailwind CSS](https://tailwindcss.com/) style directly into the `<head>` element of the index.html file:

```html
  <script src="https://cdn.tailwindcss.com"></script>

```

### Configure App.js state

Then, modify the `App.js` file using this code to set up a simple search form and a few state variables to handle every aspect of the search.

```javascript
import React, { useState, useEffect } from 'react'
import { MeiliSearch } from 'meilisearch'
import Item from './components/Item'

// TODO configure the MeiliSearch Client

const index = client.index('decathlon')

function App () {
  const [searchedWord, setSearch] = useState('')
  const [resultSearch, setResults] = useState([])

  // TODO add function to send searchedWord to Meilisearch

  return (
    <div className='mx-auto'>
      <div className='header font-sans text-white items-center justify-center'>
        <header className='py-12'>
          <img
            className='h-20 w-auto items-center justify-center p-2 mx-auto'
            src='/wide_logo.png'
            style={{ filter: 'invert(0%)' }}
            alt='Decathlon logo'
          />
          <h1 className='flex flex-wrap flex-grow text-3xl w-full justify-center p-4'>
            Stop looking for an item — find it and work hard!
          </h1>
          <div className='border rounded overflow-hidden w-full flex justify-center mx-auto searchBox mt-6'>
            <button className='flex items-center justify-center px-4 shadow-md bg-white text-black'>
              <svg
                className='h-4 w-4 text-grey-dark'
                fill='currentColor'
                xmlns='http://www.w3.org/2000/svg'
                viewBox='0 0 24 24'
              >
                <path d='M16.32 14.9l5.39 5.4a1 1 0 0 1-1.42 1.4l-5.38-5.38a8 8 0 1 1 1.41-1.41zM10 16a6 6 0 1 0 0-12 6 6 0 0 0 0 12z' />
              </svg>
            </button>
            <input
              type='text'
              value={searchedWord}
              onChange={(event) => setSearch(event.target.value)}
              className='px-6 py-4 w-full text-black'
              placeholder='Product, sport, color, …'
            />
          </div>
        </header>
      </div>
      <div>
        <div className='flex flex-wrap searchResults'>
          // TODO iterate over the search results to display them with the Item component
        </div>
      </div>
    </div>
  )
}

export default App


```

This code should output this beautiful header with a search form.

![Decathlon header with a search bar](https://unable-actionable-car.media.strapiapp.com/download_60983dd13f.png)

Search results in React
-----------------------

Connecting React with Meilisearch using the [Javascript SDK](https://github.com/meilisearch/meilisearch-js/) is a simple operation that can be done in just a few steps.

### Meilisearch client

Install the Meilisearch SDK using the following command:

```json
// if you use npm
npm install meilisearch
// if you use yarn
yarn add meilisearch

```

Set up the Meilisearch client with the server URL. In our case, it was the localhost Docker machine. Finally, load the right index from the backend.

Replace this comment in `App.js` with the code snippet below:

"// TODO configure the Meilisearch Client"

```javascript
import { MeiliSearch } from "meilisearch";

const client = new MeiliSearch({
  host: "http://localhost:7700/",
});

const index = client.index("decathlon");

```

### Send the search query

Add a `useEffect` hook to execute the search of the typed words into Meilisearch. All the results will be set to a simple state variable called `resultsSearch`.

Replace this comment in `App.js` with the code snippet below:

"// TODO add function to send searchedWord to Meilisearch"

```javascript
  useEffect(() => {
    // Create a scoped async function in the hook
    async function searchWithMeili() {
      const search = await index.search(searchedWord);
      setResults(search.hits);
    }
    // Execute the created function directly
    searchWithMeili();
  }, [searchedWord]);

```

### Showcase the results

You will iterate over the JSON objects returned by Meilisearch —they'll have the same structure as the uploaded JSON objects— and you'll display them in an `Item` component, linking to the product pages.

Let's create the `Item` component that will help us display our products. Create a components folder with an `Item.js` file inside, and copy-paste the following code snippet:

```javascript
function Item ({ url, image, name, category, vendor, price, id }) {
  return (
    <div className='flex w-full sm:w-1/2 md:w-1/3 lg:w-1/4 xl:w-1/6 p-3' key={id}>
      <a className='flex-1 rounded overflow-hidden shadow-lg' href={url}>
        <img
          className='w-full h-48 object-cover'
          src={image}
          alt={name}
          onError={(e) => {
            e.target.onerror = null
            e.target.src = '/wide_logo.png'
          }}
        />
        <div className='px-6 py-3'>
          <div className='font-bold text-sm mb-1 text-gray-600 capitalize'>
            {category}
          </div>
          {name}
          <div className='font-bold text-xl mb-2 text-gray-800'>
            {vendor} -
          </div>
          <p className='text-black text-xl font-bold text-base py-2'>
            $ {price}
          </p>
        </div>
      </a>
    </div>
  )
}

export default Item

```

Then, replace this comment in `App.js` with the code snippet below:

```javascript
{resultSearch?.map((result) => (
    <Item
      url={result.url}
      image={result.images}
      name={result.name}
      category={result.category}
      vendor={result.vendor}
      price={result.price}
      key={result.id}
      />
))}

```

You can have a look at the fullcode on [GitHub](https://github.com/meilisearch/tutorials/tree/main/src/react-decathlon/src/App.js).

![](https://unable-actionable-car.media.strapiapp.com/showcase_1578bbacab.png)

Configure the search
--------------------

With Meilisearch, you get a ton of customization options for fine-tuning your search experience. We will take a look at a few features here. You can read more about them in the [documentation](https://docs.meilisearch.com/learn/getting_started/customizing_relevancy.html).

### Search Ranking

We will start with changing the ranking rules, the criteria Meilisearch uses to sort the documents you uploaded whenever a search query is made. The order of the ranking rules influences the relevancy of your search results. You can learn more about it in the [documentation](https://docs.meilisearch.com/learn/core_concepts/relevancy.html#ranking-rules).

Let's use the following order:

```json
[
  "words",
  "typo",
  "proximity",
  "attribute",
  "sort",
  "exactness",
  “creation_date:desc”
]

```

This uses the default order along with a custom rule: `creation_date`. This rule ranks items by their creation date if all previous values are identical.

### S**earchable attributes**

You can also configure [searchable attributes](https://docs.meilisearch.com/learn/configuration/displayed_searchable_attributes.html#searchable-fields). These are attributes whose values Meilisearch searches for matching query words. By default, all attributes are searchable, but you can configure it so that it only searches the `name`, `vendor`, `category`, and `tags` fields, leaving out `images` and `URL`:

```json
searchableAttributes: ["name", "vendor", "category", "tags"]
```

### Displayed attributes

Displayed attributes are attributes that Meilisearch can return to the user in the front-end application with the [displayedAttributes](https://docs.meilisearch.com/learn/configuration/displayed_searchable_attributes.html#displayed-fields) array. Like searchable attributes, all attributes are displayed by default.

```json
    "displayedAttributes": [
      "name",
      "vendor",
      "category",
      "tags",
      "images",
      "url"
    ]
```

### Upload the new settings to Meilisearch

It’s time to customize our Meilisearch index with the search settings explained above.

```javascript
const { MeiliSearch } = require('meilisearch')

;(async () => {
  try {
    const config = {
      host: 'http://localhost:7700'
    };

    const meili = new MeiliSearch(config);
    
    const index = meili.index("decathlon");

    const newSettings = {
      rankingRules: [
        "words",
        "typo",
        "proximity",
        "attribute",
        "sort",
        "exactness",
        "creation_date:desc"
      ],
      searchableAttributes: ["name", "vendor", "category", "tags"],
      displayedAttributes: [
        "name",
        "vendor",
        "category",
        "tags",
        "images",
        "url"
      ]
    };

    await index.updateSettings(newSettings);
        
  } catch (e) {
    console.error(e);
    console.log("Meili error: ", e.message);
  }
})();


```

Conclusion
----------

This quick search wouldn’t be possible without an incredible team working on this great project night and day! If you enjoy contributing to the Meilisearch family, check out the following repositories:

*   [Meilisearch](https://github.com/meilisearch/MeiliSearch)
*   [meilisearch-js](https://github.com/meilisearch/meilisearch-js)

* * *

Get these monthly updates straight to your inbox by subscribing to our [newsletter](https://meilisearch.us2.list-manage.com/subscribe?u=27870f7b71c908a8b359599fb&id=79582d828e&ref=blog.meilisearch.com).

For more things Meilisearch, join our developers community on [Discord](https://discord.meilisearch.com/?ref=blog.meilisearch.com). You can learn more about the product by checking out the [roadmap](https://roadmap.meilisearch.com/?ref=blog.meilisearch.com) and participating in [product discussions](https://github.com/meilisearch/product/discussions?ref=blog.meilisearch.com).

How to implement instant search in your React app

We are happy to announce that Meilisearch has raised a 15M$ Series A. This round was led by [Felicis](https://www.felicis.com/news/meili) with the participation of [Guillermo Rauch](https://twitter.com/rauchg), CEO of Vercel, and our existing investors [CRV](https://www.crv.com/), [Mango Capital](https://www.mangocapitalinc.com/), [LocalGlobe](https://localglobe.vc/), and [Seedcamp](https://seedcamp.com/). This new financing will help us to fulfill our mission—making search more accessible and more efficient for everyone—while allowing us to bring Meilisearch to an even larger audience worldwide.

A brief history of Meilisearch
------------------------------

We founded Meilisearch in 2019 because we were dissatisfied with the search solutions available on the market. We noticed how slow and irrelevant search results could degrade user experience in apps and websites. There had to be a better way.

While working on search technology at large e-commerce companies, we gained experience in building efficient search engines. So we decided to create our own search engine from scratch in Rust, and we open-sourced it to help every other developer struggling like us.

![A4 - 2.png](https://unable-actionable-car.media.strapiapp.com/A4_2_f84c47f309.png)

Meilisearch timeline

In 2020, we introduced Meilisearch to the world. In no time at all, hundreds of developers and organizations worldwide had embraced it. After witnessing such quick user adoption, we realized that there was a significant product-market fit.

![star-history-20221013.png](https://unable-actionable-car.media.strapiapp.com/star_history_20221013_2787264894.png)

GitHub star growth

Since then, we have experienced incredible growth in open-source adoption—one of the fastest growth rates of any COSS project. Our GitHub star traction is an indicator of how trendy Meilisearch has become, as well as how eagerly awaited our product has been by a massive community. Every month there are more than 100K users downloading Meilisearch and more than 10K applications using it.

This will remain unchanged
--------------------------

Meilisearch is and will always be open source. It’s part of our DNA and will stay in our company culture and how we think about products for as long as we exist.

Working in open source is incredibly rewarding, particularly with a community like ours. Our community members actively contribute to our codebase and our roadmap. Through their feedback, they help us consider use cases we wouldn’t have thought of. They’re our best ambassadors and introduce Meilisearch usage within their companies. I don’t know how Meilisearch could exist without the support of our community.

![Meilisearch {"<3"} Open Source](https://unable-actionable-car.media.strapiapp.com/A4_4_56bbfc7ad3.png)

Meilisearch {"<3"} Open Source

Creating a company has one huge advantage: you can shape it as you want. Meaning that you have full power over not only the direction the product is growing in, but also the culture the company will have. I’m so proud of the fantastic team we have created at Meilisearch. Through our joint effort, we have succeeded in creating a truly remarkable place to work.

![A4 - 1.png](https://unable-actionable-car.media.strapiapp.com/A4_1_be49eed673.png)

Meilisearch perks and benefits

Growing a company is hard. Keeping our culture is and will be hard. That’s why we spend so much time on HR-related decisions; we know the only way to keep our culture is by ensuring that employees grow with the company and carefully hiring those who fit with what we already have. We have big objectives, but we do not want to lose anyone on the road to obtaining them.

Looking forward
---------------

When we started building Meilisearch, it was with the idea to create a search solution that could fit both individual developers’ and enterprises’ needs. While we spent the last three years focusing on creating the best tool for developers and growing our open-source community, we are now entering the next phase: scaling Meilisearch’s team, product, and business for enterprises.

It’s super simple to use and put Meilisearch into production. However, most enterprises don’t want to manage software they didn’t create. Enterprises are also asking for more than just Meilisearch, the open-source search engine: they need a search solution with scalability, geo-replication, and analytics. To answer this demand, we have developed Meilisearch Cloud, a hosted version of Meilisearch that allows users to instantaneously have access to our technology in a few clicks. We would like to thank our beta testers, without whom Meilisearch Cloud would not exist as it does today!

Let me now give you a brief overview of Meilisearch’s aspirations for the future.

### Fast everywhere

We are, without a doubt, in a global world where the users and the data can be anywhere. One core principle of Meilisearch is to return an answer to any search query in a few milliseconds. But what if the service is hosted in the US and the search request originates from the EU? The experience will be degraded due to latency. That is why, especially with Meilisearch Cloud, we would love to break this barrier by creating a globally distributed search service. It’ll be a huge and very exciting challenge for our teams to make this possible.

We don't have small dreams. In the future, we would like to see Meilisearch running on the edge! We have already worked on a bunch of prototypes, and we would love to see how this technology could improve the search experience for our clients’ apps.

### Easier than ever

In the early days of Meilisearch, we understood that developer experience is key to success. Today, we are super proud to have a product so simple that it’s possible for any developer to try it in just a few minutes. Developer experience will remain a primary focus of our product and engineering team.

There are two parts to integrating Meilisearch. The first one is connecting Meilisearch to your data and making sure it’s synchronized. The second is building an interface that allows your users access to this data through our search API.

Concerning the first one, we will make sure that it’s easy for any developer to connect Meilisearch to their stacks. We already have SDKs for most languages, integrations for the most known web frameworks, plugins, and some awesome tools. But we will go even further. Being able to connect Meilisearch to your data in a few clicks will become a reality.

On the frontend side, it’s already possible to create a custom search bar thanks to our SDKs and libraries, particularly [instant-meilisearch](https://github.com/meilisearch/meilisearch-js-plugins/tree/main/packages/instant-meilisearch). Again, we would go further. We want every developer to be able to install a high-quality search bar into their website or application with no effort. That is why we would like to simplify the front-end installation of Meilisearch to require only a single line of JavaScript.

### Smarter than before

Everyone is different, which means that for the same request, different people should receive different answers based on their preferences. Meilisearch already parses most languages perfectly—we are always improving this part thanks to the community. The next big milestone for us would be to bring even more logic into the comprehension of user intent and the personalization of users’ results based on their previous searches or external data.

Not only is each person different, but each company is too. Most companies have totally different use cases that require different search behavior. A Notion search and a Booking search will not have the same requirement or the same business logic. To be honest, that’s one of the biggest challenges regarding the search topic. Today, even if we accommodate most of the regular use cases, we have a clear view of how to make Meilisearch customizable depending on the business logic. This will allow enterprises to put their ML models right into the Meilisearch engine.

What’s next
-----------

These projects will take time. So I'd like to tease you a little bit about some of the exciting things coming up in the next few months.

The very first project is one that has been talked about for months. One of the most important projects started since the creation of the search engine. I'm talking about [Meilisearch Cloud](https://cloud.meilisearch.com/register). For the many people waiting in the waiting list and the companies that can't wait for the GA of Meilisearch Cloud, your wish will soon be granted! Our team is working hard to get it out as soon as possible.

We have a second big announcement, and it will make every developer super happy. We are super proud to announce that Meilisearch V1 is planned!

If you look hard enough, you will find traces of the release day. Even if Meilisearch has been technically stable for years, we made a bet not to go beyond V1 in order to be able to iterate as much as possible on our developer experience. This was a great success. Now that we have stabilized our API, it is time to make V1 a reality.

As we are constantly releasing new features and projects, I recommend you to subscribe to our newsletter or follow the specific repos that interest you on Github. If you have specific needs or ideas for us, don't hesitate to leave feedback on our [roadmap](https://roadmap.meilisearch.com/tabs/5-ideas).

**Join us**
-----------

As you may have already understood, we are ambitious at Meilisearch. Thanks to this last fundraising, we have everything we need to go further. The only thing we are missing now is you.

If you want to know more about how it is to work at Meilisearch, I invite you to read our [blog](/blog/tag/company-news/)r discuss it with the team on our [community Slack](https://slack.meilisearch.com). If you’re already convinced about joining Meilisearch, we have not released every open position, so don’t hesitate to make a spontaneous application. We will hire a lot of engineers, PM, PMM, and other roles in the months and years to come. [https://jobs.lever.co/meili](https://jobs.lever.co/meili)

Press kit
---------

**Read our Press Release below**

[Meilisearch series A PR October 2022](/blog/content/files/2022/10/Meilisearch-series-A-PR----October-2022-1.pdf)("Download")

**Media Coverage:**

*   Techcrunch - [Meilisearch lands $15M investment to grow its ‘search-as-a-service’ business](https://techcrunch.com/2022/10/10/meilisearch-lands-15m-investment-to-grow-its-search-as-a-service-business/)
*   Felicis Ventures - [Searching for the Edge: How Meilisearch Is Building the Search Engine of the Future](https://www.felicis.com/news/meili)

Meilisearch raises a $15M Series A to offer enterprise-focused products and services

Today, we sit down with one of Meilisearch’s Rust developers, [Many](https://twitter.com/ManyTheFish), to talk about  the work he’s been doing with [Charabia](https://github.com/meilisearch/charabia) to improve Meilisearch’s language support. 

A bit of historical context
===========================

Though Many’s first contact with Meilisearch’s language parsing started two years ago, he only began focussing on tokenization around the end of 2021. You might be asking yourself: what is tokenization? Well, Many tells us it is one of the most important steps when indexing documents and, in short, means breaking down search terms into units our engine can process more efficiently. The part of Meilisearch’s engine that takes care of tokenization is called a tokenizer.

Many felt the way we handled content in different languages wasn’t efficient and that, even if Meilisearch already worked very well with languages like English and French, the same could not be said about other language groups. Many explains that a lot of it comes down to the different ways we type in different languages, as well as the various ways in which we make mistakes when writing in them. A typo in Japanese or Chinese, for example, might follow a different logic than a typo in Italian or Portuguese.

A different perspective
=======================

One main issue was immediately clear to Many: it would be impossible for us at Meilisearch to master all the languages in the world and improve our tokenizer alone. Luckily,  the open-source community is a diverse and generous bunch, with people from literally all over the world fluent in more languages we can possibly name. So Many’s focus shifted from directly improving language support to making contributing as simple and painless as possible.

Two main aspects go into improving a language with our tokenizer. First, we can work on **segmentation**, which means understanding where a word starts and where it ends.  
  
_“It appears pretty obvious for English or European speakers: “split on white spaces and you get your words!"; but it becomes harder when you face other types of Languages like Chinese, where there is no explicit separator between characters”_  
  
Second, we can work on **normalization**, which encompasses canonical modifications (upper or lower case), compatible equivalence (recognising the same character under different forms; e.g: ツ and ッ), and transliteration (transposing from one alphabet to the other, e.g.: Cyrillic into Latin)—we avoid this last one  as much as possible because it often results in information loss.

_“Here it’s the same, each Language has its specificities and we have to adapt the normalization for each Language. Take the case of capitalization: we have two versions of each Latin character, a capitalized version, and a lowercased version, but this specificity doesn’t exist for all Language in the world!”_

Many’s job, then, is less about writing a lot of code, and more about researching and understanding the ins and outs of a particular language so he can judge whether a contribution is going to work well with Meilisearch.  
He explains: 

_“This all boils down to the contrast between traditional translation and a field called information research (IR). Whereas translation focuses on preserving meaning, IR can afford to be less strict and account for mistakes such as misspelled words. Focussing on IR over translation allows us to offer search options that might be irrelevant in translation work.”_ 

![](https://unable-actionable-car.media.strapiapp.com/Word_explanation_0d5b8b3fac.png)

If a user typed “mais,” they would see results for both  “but” and “corn” because Meilisearch  takes into account that a user might have forgotten or simply did not feel like using the appropriate accent when typing.

So, whenever we wish to improve support for a language, it’s not only about having the right language experts contributing to our project. It also involves an enormous investment of research time on Many’s side, so he can determine whether a change to the tokenization process of a specific language is going to return more relevant search results.

What languages have we worked on so far?
========================================

As you might have read on our [blog post about v0.29 release](/blog/whats-new-in-v0-29/)n the past two months we’ve done extensive work on improving our support for Thai. This is a feature we’re very proud of and which was only possible thanks to the open-source community.  There’s a lot of room for improvement, though: Thai segmentation in Meilisearch is great, but normalization still requires work.

We also recently improved Meilisearch’s Hebrew normalisation. Before that, we made good advances on  Japanese segmentation, but want to polish Japanese normalization to better account for things like the differences between  ツ and ッ,or ダメ and だめ.

Right now, Many is very interested in Chinese tokenization, a language that comes with  its own set of challenges. For example, Chinese comes with a number of variants depending on the location where it’s spoken: Mandarin, mainland China’s various regional uses, and Cantonese, to name just a few. Though all these variations share mostly the same characters and meanings, they are not always used in the same way, can correspond to different sounds, and thus aren’t typed by everyone in the same fashion—all of which makes it really tricky when it comes to IR. At this point, we’re unable to have competing normalizations, which led us to base normalization on the dialect with the biggest number of users.

![](https://unable-actionable-car.media.strapiapp.com/rs7352_thinkstockphotos_493800479_low_1_45c0b2cea2.jpg)

Future ambitions
================

Accommodating competing normalizations for the same language (the tolerance of multiple variants of a language) is one of Many’s top priorities right now. 

He also feels the number of languages we support is too low, so an important step is devising strategies to get more contributors involved. You might ask: what languages Many wants to focus next? He tells us it’s a complex choice: he needs to balance his own personal preferences, the languages our contributors bring forward, as well as a strategic choice based on the number of speakers of a language.

Not all languages are equal, he explains. Some are easier to handle: agglutinative languages like Turkish, for example, could be next! _“However, if a contributor would like to push forward their language, we are happy to consider their suggestion and reprioritize,”_ assures Many.

Next on the list: parsing accents, diacritics, and other non-spacing marks. Remember our “maïs” and “mais” examples earlier? At this point, the tokenizer simply remove accents, but some users may want to take these diacritics into account. Accomplishing this isn’t technically very complex, according to Many: in short, it requires establishing two distinct normalization processes—one loose (which overlooks accents) and one strict (which doesn’t ignore anything). The challenge is integrating them without slowing down the search terribly or doubling the size of the index.

How can I contribute?
=====================

Want to help? You can contribute in various ways, many of which have little to do with coding:

*   Upvote a [discussion](https://github.com/meilisearch/product/discussions): this helps Many prioritize a specific topic or language
*   Create an [issue](https://github.com/meilisearch/charabia/issues) on GitHub explaining language-related problems you experience:  for example, if you notice Meilisearch is returning erroneous results when you search for a specific word or expression
*   Know a language like the back of your hand? We’d [love to hear](https://github.com/meilisearch/product/discussions) your thoughts on challenges and possible solutions when creating segmenters and normalizers
*   [Propose tokenization libraries](https://github.com/meilisearch/charabia/issues): it’s very helpful to know about existing tools you like and think works very well for a given language
*   [Submit a PR](https://github.com/meilisearch/meilisearch/pulls) solving a problem you experienced when using Meilisearch with a specific language. Tip: clearly explaining the problem and the solution in the PR itself or in a [GitHub issue](https://github.com/meilisearch/meilisearch/issues) definitely increases the chances of getting your contribution accepted 

If you’re participating in `Hacktoberfest` right now, most of the [issues listed on Charabia’s repository](https://github.com/meilisearch/charabia/issues) are eligible for the event! PRs without a corresponding issue are also welcomed—we’ll be happy to tag it as “hacktoberfest approved” if your contribution is accepted.

Last but not least: our work wouldn’t be possible without the fantastic input we receive from the community. Thank you so much for all your effort and generosity!

Improving Meilisearch’s language support

Hi 🙂 I’m Morgane, the HR Manager at Meilisearch, a search engine startup based in France. I joined Meilisearch because I was inspired by the founders’ vision of how they wanted to treat the people working with them. Before that, I worked for several medium to large-sized startups, but struggled with company cultures that glorified their founders and profits at the cost of fostering burnout. When I started working at Meilisearch, I was actually relieved: here were the creators of a tech startup using words like “people” and “fairness” before they ever mentioned “profit” or “IPO.”

As the HR manager at a young startup, one of the first projects on my to-do list was to solve the salary problem. We had heard about salary grids being used to solve similar problems, as well as something called a career framework that could help us clarify expectations for evolution within the company. We wanted to give all that a try. We did some research and were inspired by [Buffer’s](https://buffer.com/resources/career-framework/) solution to implement our own salary grid and career framework.

![https://media.giphy.com/media/9thduMKTL4Dcc/giphy.gif](https://media.giphy.com/media/9thduMKTL4Dcc/giphy.gif)

Two years down the road, I can confidently say this was a wise choice. Using a career framework and salary grid helped us solve specific problems that are faced by most distributed tech teams while also helping us express our company values of fairness and transparency.

Publishing this article is a way for us both to thank Buffer and similar companies for being transparent about their internal structure and to give back in the same way to new companies looking to solve similar problems. Scrolling down, you will read about our philosophy around salaries, current implementation, and potential improvements we’ve identified.

The challenges of compensation for a distributed tech company
=============================================================

Today we are a tech company distributed between Europe, South America, Africa, and the Middle East. As such, here are some of the challenges we are facing:

*   **Overbid:** Paying too much for software engineers. We mostly hire software engineers or people from the tech space. This means profiles can be rare, expensive, or both.
*   **Gender gap:** In 2021, a survey from [Hired](https://hired.com/h/wage-inequality-report/2021/) showed that in the tech space specifically, men were offered higher salaries than women for the same job title at the same company 59% of the time. One way to fight this kind of culture is by being transparent about what we pay people, de-emphasizing the role of negotiation in salary determination.
*   **Competitive hires:** Remote work has become ubiquitous in the tech industry during the past few years. Today, engineers can work from anywhere in the world. This puts us in direct competition with ********everyone********, including Silicon Valley-based tech companies that offer very high salaries.
*   **Diversity:** similar to the gender gap, salary systems that are opaque or negotiation-based tend to favor groups that are already highly privileged.
*   **Cost of living:** As a remote company, we can hire people anywhere worldwide, provided the time difference is manageable. This poses ethical issues regarding salaries: how do we make sure we pay our employees fairly given differences in cost of living, taxes, and market value?

Developing a salary grid is part of our solution to address issues such as internal retention, external attractiveness, and diversity & inclusion.

The principles behind our salary grid
=====================================

In January 2021, we implemented a career evolution framework and a salary grid. According to the grid, different teams and jobs are rewarded differently, based on data from [Figures](https://figures.hr/). We do regular benchmarking to make sure we stay relevant to the market and show team members we have fairness at heart.

The grid is [public](https://docs.google.com/spreadsheets/d/1yds9Wg4eAHQ0hmD4bvQspwqxp6UArXikXnxZEiAjxwg/edit?usp=sharing), so everyone individually knows where they stand. It’s a good way of avoiding arbitrary negotiations so that the best salary doesn’t always go to the pushiest negotiator. This initiative fits with important parts of our values and culture, such as openness, equality, and transparency.

![](https://unable-actionable-car.media.strapiapp.com/roman_synkevych_a_Sj_J_a_Cz_R7_Q_unsplash_f7c9afe080.jpg)

Regarding location, we chose to offer equal pay for equal work by basing gross salaries on the total cost for Meilisearch. So whether you’re a Product Manager working with us remotely in Cairo or Montreal, the base for calculating your salary will be the same: the only possible difference in your net salary will be the local taxes.

Moreover, with transparency in mind, we are able to show our grid to candidates in order to be completely transparent when we make an offer. We don’t want offers to be based on a candidate’s minimum salary expectation because this can perpetuate existing inequality.

It’s also important for us to specify that our [4-day work-week](/blog/how-we-implemented-the-4-day-work-week/ doesn’t impact salaries. As a Meilisearch employee, you’ll be paid as if you were working five days per week.

Our journey into compensation models
====================================

Our first salaries were set on French standards, with what we knew of the industry. A few months later, in an initiative to have a more data-oriented approach, we subscribed to [Figures](https://figures.hr/), a salary benchmarking tool that helped us reevaluate all our salaries at the end of 2021 to the top 25%, according to the data at our disposal.

After raising salaries to the top 25%, we thought our troubles were over. However, our salaries were based on European data; this meant that our salaries were insufficient to attract candidates from other parts of the world, and to retain our employees who had gained more experience and become desirable hires. This pushed us last September to reevaluate compensation for Software Engineering and Technical Writing based on an aggregation of data from Figures and a benchmark of salaries announced in job descriptions from tech companies in the US (for instance, the job board from [The Pragmatic Engineer](https://blog.pragmaticengineer.com/)).

Most people we have hired and the candidates we interview make it clear they’re interested in the potential of Meilisearch and our company culture above anything else. Having said that, let’s be honest: a large difference in salary can shift the balance of interest pretty quickly. **It’s important for us to have a competitive salary grid for our fully remote & distributed team and future hires.**

This is what our grid for Software Engineering looks like today:

|     |                     |              | Total cost for company | TCC       | TCC       | TCC       |
|-----|---------------------|--------------|-------------------------|-----------|-----------|-----------|
|     | IC                  | Manager      | 1                       | 2         | 3         | 4         |
|     | Software Engineering|              |                         |           |           |           |
| 1   | Entry               |              | €67,410                 | €73,149   | €78,888   | €84,628   |
| 2   | Intermediate        |              | €90,367                 | €96,106   | €101,845  | €106,933  |
| 3   | Advanced            | Lead         | €112,022               | €117,110  | €122,198  | €127,287  |
| 4   | Highly skilled      | Manager      | €132,375               | €138,133  | €143,891  | €149,649  |
| 5   | Specialist          | Senior Manager | €155,407             | €161,165  | €166,923  | €172,681  |
| 6   | Principal           | Director     | €178,439               | €184,197  | €189,955  | €195,713  |


How is it applied internally?
=============================

👉 **Our base: the total cost for the company** 🌎

Each team member’s salary is calculated according to their total cost for Meilisearch. The `total cost for company` value is used to calculate a gross salary or contractor fee. We calculate employer costs in each country based on the data provided by [Oyster HR](https://www.oysterhr.com/), which acts as an intermediary for international contracts.

The gross salary for an employee is then defined by considering employer costs and/or country-specific taxes. Here is a visual example of what this might look like:

|  | Total annual cost for company | Gross annual salary - Pre-tax |
| --- | --- | --- |
| France | €122,000.00 | €83,500.00 |
| Nigeria | €122,000 (₦52M) | €92,109 (₦40M) |
| USA | €122,000 ($120,183) | €96,790 ($95,634) |

Our formula for gross salaries is the following:

```markdown
total cost for company, minus: 

 - employer costs in specific country 
 - lunch stipend (same for everyone)
 - working from home stipend (same for everyone)
 - health insurance (if not included in employer costs)
 - Oyster HR fee

= gross salary for employees

```

👉 **What about contractors?** 🤨

Unfortunately, we lack data to automatize calculations for contractor fees. We start from the `total cost for the company` value, subtract the fees from Oyster HR, and offer a lump sum to the contractor who then handles the rest themselves.

This solution isn’t perfect
===========================

And it never will be. While we do have a solution that we find works well to compensate employees fairly and equally, we’ve identified areas of improvement that we will need to address going forward.

From an ideological standpoint, the evolution of our salary grids has marked a further distance between the salaries of developers and non-developers. Although these roles are not always cut and dry, we can see that software engineering as a skill is being valued very highly in the market. In time, this may create a sense of unwanted inequality. It also reminds us once again how dependent we are on the laws of the current market trends and obliged to react—dare I say _obey_?—to a senseless overbid on salaries in the tech space.

This market trend causes another problem for us: offering more money to stay relevant to candidates internationally. We know we will need to but are unfortunately limited in our current stage of development.

![](https://unable-actionable-car.media.strapiapp.com/brian_wangenheim_TEN_18_DN_8_KP_8_unsplash_e6b81cc129.jpg)

Finally, we can still improve our data-based approach to compensation. We will need, for instance, clear and relevant data regarding developer advocacy and technical writing jobs. These two fields may be well-known in Anglophone countries but aren’t very developed in Europe, thus making salary information scarce. For this, we are adapting this grid as we go along: meeting candidates and discussing their expectations help us gather insights.

All in all, we know there is more room to grow within this approach. However, we and all companies have leeway to create the future of work as we want to see it. One brick at a time, we’re getting there.

Thanks for reading
==================

Defining our policy and implementing this grid resulted from hours spent on the internet searching what other companies were doing, many internal discussions, and a few video calls with peers from tech startups.

With this article, I hope to help other businesses reflect on their compensation system. I’m also hoping to spark conversations and share ideas. Feel free to [reach out to me](https://www.linkedin.com/in/morgane-neff-8b1334102/) if this is something you’re interested in discussing!

Also… we’re hiring 🤩 If you want to join us, check are our [open roles](https://jobs.lever.co/meili/).

“Bills, Bills, Bills”: our approach to salaries at Meilisearch

We're halfway through Hacktoberfest, an excellent time to look back and see how much we have accomplished so far. It's also an opportunity to recenter ourselves for the next couple of weeks and conclude this event with a bang.

We're incredibly proud to share that, so far, we've merged 92 pull requests! We're baffled by our contributors' enthusiasm and involvement. We wish to extend a warm thanks to everyone who participated.

And to express our gratitude, we'd like to share our plans for additional Meilisearch swag and common goals, as we teased in our previous Hacktoberfest [blog post](/blog/contribute-hacktoberfest-2022/)*Meilisearch exclusive swag**
------------------------------

Last year, we sent reusable bottles and some stickers to our contributors. When it came to shipping, it was not all smooth sailing, but we learned a lot from it and have adjusted our strategy this year.

We had settled on reusable bottles in the spirit of eco-friendly and reusable gifts. These values are fundamental to us as we wish to offer goods people can reuse for a long time. Given that most  of our contributors are developers, we've considered that tech-related presents might be particularly appreciated. This is how we came to our current choice.

We're very excited to be able to give all participants a swag box containing a duffle bag, a webcam cover, as well as a touchscreen tool shield.

![Picture of the swag box products such as a dark duffle bag, a black webcam cover, a white touchscreen](https://unable-actionable-car.media.strapiapp.com/Untitled_design_6_1f6a37b53c.png)

(This isn't the final design of the goods you'll receive :) )

The touchscreen will ensure you won't have to touch public surfaces and keep your hands germ-free. The webcam cover will guard your privacy. And finally, you'll be able to put all your gifts in your snazzy duffle bag-both, a fashionable _and_ green choice.

If you've had one of your PRs merged or will get one merged before the end of Hacktoberfest, you're eligible to receive your box! Our maintainers will share a link to a simple online form where we will collect the information we need to start the redeeming process.

**Common goals** 
-----------------

As we did [last year](/blog/hacktoberfest-2021-recap/)e strive to not only contribute to the open-source community throughout Hacktoberfest but also hope to pay it forward. This is why we come back again with some collective goals to benefit a greater mission.

For Hacktoberfest 2021, we donated to open-source maintainers, climate activist groups, and groups that support diversity in tech.

This year, we identified local groups that might benefit from our contributions and with whom we hope to foster a closer relationship. We'd love to see how our donations -achieved thanks to you!- will impact their work.

These are the different groups we plan on supporting this year:

### **Group 1. Diversity in tech**

Diversity in tech is, now more than ever, a hot topic. We strive for a world where diversity isn't a debate topic but a simple reality. Within Meilisearch, we do our best to encourage inclusion and acceptance, and we are very grateful for the opportunity the diversity our mostly remote team offers us.

This is why we wish to keep supporting such topics through the following associations:

👩🏿‍🦱 [Women on Rails](https://women-on-rails.github.io/ressources/) - This LGBTQ+-friendly association works hard to support women that want to practice coding on Ruby and Rails, specifically.

👩🏾‍💻 [Ladies of Code Paris](https://ladiesofcodeparis.netlify.app/) - This Paris-based group supports women's careers in tech.

👥 [Becometech](https://becomtech.fr/en/why-support-us/) - Once again, this Paris-based group strives for inclusion and diversity in IT.

### **Group 2. Climate activism**

As a tech company, we are aware of our carbon footprint. To further our efforts in minimizing this impact, we wish to continue to support some climate activist causes such as:

🌊 [Seasheperd France](https://seashepherd.fr/) - This group works on protecting oceans and raises awareness against aggressive fishing practices.

🌏 [Teragi](https://www.teragir.org) - This association supports sustainability projects through five different active programs

🌴 [Reforestaction](https://www.reforestaction.com/nos-solutions-pour-les-entreprises) - This group pushes hard on reforestation efforts.

### **Group 3. Societal organizations** 

Finally, our third group this year tackles social issues. The members of Meilisearch hope to leave this world in a better state than we found it. In these uncertain times where it's so easy to feel divided, we wish to stand together and support the following groups:

👭 [MAS les Sophoras , Unapei Alpes Provence](https://annuaire.action-sociale.org/?p=mas-les-sophoras-130008402&details=caracteristiques) - This French, Marseille-based, association supports disabled adults throughout their lives by helping integrate them into society.

🇺🇦 [Urgence: santé des femmes Ukrainiennes](https://www.helloasso.com/associations/asf-actions-sante-femmes/collectes/urgence-femmes-ukrainiennes) - This group supports Ukrainian women's health who had to flee their country due to the war, especially with pregnancies.

👫 [Perce neige](https://www.perce-neige.org/) - This Marseille-based group works on supporting mentally handicapped adults. 

**How to unlock the donations?**
--------------------------------

This year, the sky's the limit! It will take 50 PRs to go from one stage to the other, meaning each merged PR represents 10€ of donation.

![Picture displaying the 4 goals we hope to achieve with the appropriate monetary donation next to each goal. ](https://unable-actionable-car.media.strapiapp.com/Goal_1_a57a68e5ff.png)

To calculate the total number of contributions, we will count the number of  Hacktoberfest-related pull requests merged in Meilisearch repositories at the end of the month. We will also consider any PRs tagged with the “Hacktoberfest-accepted” label but have not been merged.

As we mentioned, we've already merged 92 PRs we're happy to announce we've already achieved the first goal on our list! Each of our three groups will be receiving 500€, and that's thanks to your efforts! Let's work hard to bring these donations to the next level by smashing through the rest of our goals.

### **How to participate?**

You still have time to participate for a chance to get your hands on our exclusive swag box and help in achieving our common goals!

You can find all our repos accepting Hacktoberfest contributions [here](https://github.com/search?q=org%3Ameilisearch+topic%3Ahacktoberfest&type=Repositories); alternatively, all our Hacktoberfest-eligible issues are [here](https://github.com/search?q=org%3Ameilisearch+label%3Ahacktoberfest&state=open&type=Issues).

There is an issue for everyone, with plenty of [good first issues](https://github./blog/2020-01-22-how-we-built-good-first-issues/) for more novice contributors and more challenging topics for our seasoned devs.

Here are our suggestions for repos that contain some interesting good first issues:

*   If you're a language expert, you'll find many issues in [Charabia](https://github.com/meilisearch/charabia) that require your knowledge of the language to improve our tokenizers and make it easier for Meilisearch to process foreign languages. 
*   Our [PHP](https://github.com/meilisearch/meilisearch-php) integration also offers some issues you might be able to tackle without too much trouble if you're interested.
    

And, of course, if your PR is not associated with an issue, but gets accepted, we'll be happy to tag it as "Hacktoberfest accepted", so don't let that stop you!

### **Join our community!**

Our [Slack community](https://join.slack.com/t/meilicommunity/shared_invite/zt-1g4juofj9-FAc_X_A_Ka8EJ6hUMauQCA) is always open to new members! We have a #[hacktoberfest](https://meilicommunity.slack.com/archives/C02G1H43J2X) channel where both Meilisearch employees and fellow contributors mingle, so don’t hesitate to join us if you’d like.

We look forward to your feedback on yourHacktoberfest experience.

Hacktoberfest 2022: Mid-October update

With Hacktoberfest in full swing, contributors and maintainers alike are busier than ever. But this month is not only about writing code and opening PRs—it is also about connecting with people and becoming part of a community. We would like to take this time to share a Hacktoberfest story that’s very dear to us. 

Meet [Bruno Casali](https://meilisearch.notion.site/Bruno-Casali-49a83569f1e54ba1b3276e257ff4d165), Meilisearch’s very own Integrations Team Lead! Bruno was scouted last year following his participation in Hacktoberfest, going from occasional external contributor to a key Meilisearch employee. He kindly agreed to share his thoughts and experience with us.

![Portrait of Bruno Casali](https://unable-actionable-car.media.strapiapp.com/rsz_1rsz_05_1_c1b1d3380e.jpg)

Contributing to Hacktoberfest
=============================

First of all, it’s important to know last year wasn’t Bruno’s first rodeo. 

_“I have participated in Hacktoberfest since 2016 (the second year). I have always been that developer who tries to find good repositories to contribute to, and suddenly, with Hacktoberfest, I could be rewarded in some way for doing that. I immediately saw it as an opportunity to meet people from different countries making contributions to open-source and found out it was also a way for me to validate my programming knowledge.”_

We were curious to hear about what made Hacktoberfest such a peculiar time of the year for the participants. He explains to us that the atmosphere is very different, for both maintainers and participants, who are 100% focused on their objectives:

_“You can expect a lot of activity in your repositories (sometimes even 20x more than usual) and meeting people from around the world. Big projects receive even more attention. It’s a good time to show up and do great things: not only can you learn a lot, but maybe the people you’re collaborating with can see you as a potential employee.”_ 

When it came to his favourite part of Hacktoberfest, Bruno was emphatic: it was all about connecting with the community. _“I enjoyed Hacktoberfest for many reasons. It was a time to meet new people (mostly people from outside of my native country) and show I'm a good developer. It was also an opportunity to create a portfolio for my work.”_

Communication is not always easy nor smooth, though: 

_“Unfortunately, some maintainers neglect communicating with contributors. Sometimes honest attempts at solving an issue are completely ignored and this represents for me the worst possible thing. Because I, as a contributor, am not paid for that work. I invested my time and I expect something in exchange, even if it is just a ‘hey, you did it wrong’ so I can learn from that experience. And of course I don’t get that if the maintainers just disappear.”_ 

Which is a very good reminder for us maintainers to respect the time and energy invested into our projects by Hacktoberfest participants.

![Hacktoberfest x Meilisearch crossover logo](https://unable-actionable-car.media.strapiapp.com/Frame_9_4389751892.png)

From contributor to maintainer
==============================

We were of course interested in knowing how Bruno found Meilisearch and why he decided to contribute:

_“Hacktoberfest 2021 was the first time I heard about Meilisearch. I was looking for projects offering extra swag for contributors and found Meilisearch in a [random list](https://hacktoberfestswaglist.com/list/#meilisearch) out there. I checked if they had any repositories I could contribute to and found the [Ruby](https://github.com/meilisearch/meilisearch-ruby) and [Ruby on Rails](https://github.com/meilisearch/meilisearch-rails) integration repos.”_

A lot of repositories take part in Hacktoberfest, so we wondered: how was working with the Meilisearch team when compared to other companies?

_“The first contact was amazing! The Integrations Team answered quickly, so it made me want to keep contributing, because I felt I was part of the project, that Meilisearch was a place where I could actively make a difference. It was a very positive experience and I could feel that Meilisearch was different.”_

This eventually led to an unexpected (but very pleasant) surprise:

_“Then, 10 days after my first contribution, [Morgane Neff](https://meilisearch.notion.site/Morgane-Neff-ce9c8e7d86ab46a6bdd64b3164bbec25), Meilisearch’s HR Manager, reached out to me with a job offer. I was quite surprised about that, because I've never had that kind of response to one of my contributions before, I felt amazing.”_

One year later, we asked Bruno to reminisce on his transition and if the change from participant to employee was an easy one.

_“I maintain my own open-source projects, so in some aspects the transition was easy. Something I was not used to was dealing with interpersonal conflicts during code reviews. Other situations can be a bit awkward, like external users complaining about something in our repositories. Also, my role at Meilisearch is to manage the Integrations Team, which means I'm responsible for 30+ repositories with multiple tech stacks. Keeping on top of each one of them requires a lot of context-switching, which can be difficult.”_

Open-source ♥️ 
===============

In the end, Bruno says, the secret to a great Hacktoberfest experience is very simple:

_“Love the process of contributing to open-source, love the idea of meeting people who can teach you, love the idea of teaching others through your own contributions. You have nothing to lose and everything to gain by doing that._

_“And, if you want to work for an open-source company, you can see your contributions as a coding test. Do your best, be kind with the maintainers—rinse and repeat 😊”_

We are super grateful to Bruno for sharing his experience! We hope his story can motivate anyone out there wondering whether they should get involved in open-source development. If you wish to contribute to Meilisearch during Hacktoberfest and get some of our exclusive swag, find all our Hacktoberfest eligible issues on [Github](https://github.com/search?q=org%3Ameilisearch+label%3Ahacktoberfest&state=open&type=Issues) and check out our dedicated #[hacktoberfest](https://meilicommunity.slack.com/archives/C02G1H43J2X) channel on Slack.

And again, to all Hacktoberfest participants: good luck and keep up the great work!

  
  
  

=========

Hacktoberfest stories: from contributor to manager

Meilisearch v0.29 is out and comes with a new feature: matching strategy customization!

Consider the following situation: a user sends a two-word search request. What happens when there are not enough documents to meet the requested `limit`? Should the engine only return documents with all the query terms? Or should it return more documents? If so, which criteria should it apply to return them?

That’s where  matching strategies come in. A matching strategy is used to match query terms when the engine has not found enough documents containing all query terms. It’s not an easy decision to make, and it’s highly dependent on the type of data the user is searching for. Fortunately, now you can choose the strategy to apply at search time 🎉

**A little bit of history**
---------------------------

Back in 2021, all versions pre v0.21 only returned documents where all the query terms were present. So if I searched for “Peter Parker”, it would just return documents in which both terms —“peter” and “parker”— were present. This matching strategy is called: `all` because **all** query terms must be present in the document for it to be returned.

![You're welcome GIF](https://unable-actionable-car.media.strapiapp.com/image_8205358452.gif)

[Ranking rules](https://www.meilisearch.com/docs/learn/core_concepts/relevancy#ranking-rules) are one of Meilisearch’s most important features for  ensuring relevant results. The _[words](https://www.meilisearch.com/docs/learn/core_concepts/relevancy#1-words)_ ranking rule states the following:

Results are sorted by decreasing number of matched query terms. Returns documents that contain all query terms first.

This rule had been lying around in our documentation for a while, coupled with the following warning message:

For now, it is mandatory that all query terms are present in returned documents. Therefore, this rule does not impact search results yet.

With v0.21, the words rule started working, so this warning disappeared with the all-query-terms-present constraint.

From that point on, if there were not enough documents containing all query terms, Meilisearch removed one term at a time, starting from the end of the query. So if I searched for “Peter Parker”, it would first return documents in which both terms were present, followed by documents with just “Peter”

This type of matching strategy is called `last` because Meilisearch removes the **last** term of the query.

![Nailed it GIF](https://unable-actionable-car.media.strapiapp.com/image_1_533740ccdb.gif)

It turned out that many users were pretty content with the previous matching behavior. Unfortunately, this change did not allow them to migrate to a newer version of Meilisearch, which prevented them from benefiting from its many improvements: sorting at search time, geosearch, granular API keys rights, multi-tenancy, etc. Not only were they missing all that, but they were going to miss all the awesome features to come! 😱

Don’t panic! Version 0.29 has come to the rescue!

**Closing the feedback loop**
-----------------------------

Now, it’s possible to choose your desired matching strategy at search time. The default strategy is `last`; if you want to use `all`, all (wink wink) you need to do is specify it in the search body as follows:

```bash
curl \
  -X POST 'http://localhost:7700/indexes/movies/search' \
  -H 'Content-Type: application/json' \
  --data-binary '{ "q": "peter parker", "matchingStrategy": "all" }'
```

This feature has been in the works since September 2021, when [Guillaume Mourier](https://github.com/gmourier/), our Product Manager, started the [“Policy for matching query words” discussion](https://github.com/meilisearch/product/discussions/255) to collect feedback on the matter. We would like to thank everyone involved for taking the time to share their input 🙏 Meilisearch would not exist as it does today without the support from our community 🥰

There are as many reasons to use either strategy as there are many use cases. Not sure yet which one to choose? I’ve created a demo so you can test both strategies to help you make up your mind 😊

<Callout>
  For more in-depth information on matching strategy customization, you can read the [dedicated section](https://www.meilisearch.com/docs/reference/api/search#matching-strategy) of the documentation.
</Callout>

**The demo**
------------

This demo uses the [movies dataset](https://www.meilisearch.com/movies.json), used in Meilisearch’s [quick start guide](https://www.meilisearch.com/docs/learn/getting_started/quick_start) and widely throughout the [documentation](https://www.meilisearch.com/docs).

I have made no changes whatsoever to the settings. I have simply indexed the dataset and have kept the default configuration. Pure as the driven snow ❄️

When performing a search, you can click on the button to modify the `matchingStrategy` search parameter and see the different results depending on the strategy used.

Try it here 👉 [matching-strategy.meilisearch.com](http://matching-strategy.meilisearch.com)

If you lack ideas or need some inspiration for query terms, I have listed some query ideas, ranging from 2 to 10-word queries:

*   forrest gump
*   big fat liar
*   return to never land
*   the purple rose of cairo
*   the curious incident of the dog in the night time

![When searching for "the hateful eight", Meilisearch finds 28412 results with the "last" matching strategy versus one result with the "all" matching strategy](https://unable-actionable-car.media.strapiapp.com/matching_strategy_488f3d6b7a.gif)

**Conclusion**
--------------

I hope this demo has helped you better comprehend the differences between the two strategies and their impact on search results. As usual, you can find [the code on GitHub](https://github.com/meilisearch/demos/tree/main/src/matching-strategy).

There are numerous ways of fine-tuning the relevancy of your search results. This is just one of the many options available. We know every project is different and has its own requirements; that’s why your feedback is so important to us. We work to make it easy to customize your instance so that you can deliver the best search experience to your users.

Don’t hesitate to check our [product repo](https://github.com/meilisearch/product/discussions) and make a suggestion or join an existing discussion on improving the product.

If you like Meilisearch and want to support us, a star on [GitHub](https://github.com/meilisearch/meilisearch) means a lot 😇

Meilisearch latest news and company updates