diff --git a/src/model/model_helper.py b/src/model/model_helper.py
index 4e1dd25c..b4777967 100644
--- a/src/model/model_helper.py
+++ b/src/model/model_helper.py
@@ -4,6 +4,7 @@
 
 import utils.env_utils as env_utils
 from config.constants import FILE_TYPE_DIR, FILE_TYPE_FILE
+from utils.string_utils import is_blank
 
 ENV_VAR_PREFIX = '$$'
 SECURE_MASK = '*' * 6
@@ -134,7 +135,7 @@ def read_int_from_config(key, config_obj, *, default=None):
     raise InvalidValueTypeException('Invalid %s value: integer expected, but was: %s' % (key, repr(value)))
 
 
-def read_str_from_config(config_obj, key, *, default=None):
+def read_str_from_config(config_obj, key, *, default=None, blank_to_none=False):
     """
     Reads string value from a config by the key
     If the value is missing, returns specified default value
@@ -143,9 +144,14 @@ def read_str_from_config(config_obj, key, *, default=None):
     :param config_obj: where to read value from
     :param key: key to read value from
     :param default: default value, if config value is missing
+    :param blank_to_none: if value is blank, treat it as null
     :return: config_obj[key] if non None, default otherwise
     """
     value = config_obj.get(key)
+
+    if blank_to_none and isinstance(value, str) and is_blank(value):
+        value = None
+
     if value is None:
         return default
 
diff --git a/src/model/script_config.py b/src/model/script_config.py
index af71865a..dd5af0e0 100644
--- a/src/model/script_config.py
+++ b/src/model/script_config.py
@@ -6,7 +6,8 @@
 
 from auth.authorization import ANY_USER
 from model import parameter_config
-from model.model_helper import is_empty, fill_parameter_values, read_bool_from_config, InvalidValueException
+from model.model_helper import is_empty, fill_parameter_values, read_bool_from_config, InvalidValueException, \
+    read_str_from_config
 from model.parameter_config import ParameterModel
 from react.properties import ObservableList, ObservableDict, observable_fields, Property
 from utils import file_utils
@@ -19,6 +20,7 @@ class ShortConfig(object):
     def __init__(self):
         self.name = None
         self.allowed_users = []
+        self.group = None
 
 
 @observable_fields(
@@ -235,6 +237,7 @@ def read_short(file_path, json_object):
 
     config.name = _read_name(file_path, json_object)
     config.allowed_users = json_object.get('allowed_users')
+    config.group = read_str_from_config(json_object, 'group', blank_to_none=True)
 
     hidden = read_bool_from_config('hidden', json_object, default=False)
     if hidden:
diff --git a/src/tests/config_service_test.py b/src/tests/config_service_test.py
index 6befc0f5..3d9d97d4 100644
--- a/src/tests/config_service_test.py
+++ b/src/tests/config_service_test.py
@@ -31,6 +31,19 @@ def test_list_configs_when_multiple(self):
         conf_names = [config.name for config in configs]
         self.assertCountEqual(['conf_x', 'conf_y', 'A B C'], conf_names)
 
+    def test_list_configs_with_groups(self):
+        _create_script_config_file('conf_x', group='g1')
+        _create_script_config_file('conf_y')
+        _create_script_config_file('A B C', group=' ')
+
+        configs = self.config_service.list_configs(self.user)
+        configs_dicts = [{'name': c.name, 'group': c.group} for c in configs]
+        self.assertCountEqual([
+            {'name': 'conf_x', 'group': 'g1'},
+            {'name': 'conf_y', 'group': None},
+            {'name': 'A B C', 'group': None}],
+            configs_dicts)
+
     def test_list_configs_when_no(self):
         configs = self.config_service.list_configs(self.user)
         self.assertEqual([], configs)
@@ -92,26 +105,26 @@ def test_list_configs_when_no_constraints(self):
         _create_script_config_file('a1')
         _create_script_config_file('c2')
 
-        self.assert_list_configs(self.user1, ['a1', 'c2'])
+        self.assert_list_config_names(self.user1, ['a1', 'c2'])
 
     def test_list_configs_when_user_allowed(self):
         _create_script_config_file('a1', allowed_users=['user1'])
         _create_script_config_file('c2', allowed_users=['user1'])
 
-        self.assert_list_configs(self.user1, ['a1', 'c2'])
+        self.assert_list_config_names(self.user1, ['a1', 'c2'])
 
     def test_list_configs_when_one_not_allowed(self):
         _create_script_config_file('a1', allowed_users=['XYZ'])
         _create_script_config_file('b2')
         _create_script_config_file('c3', allowed_users=['user1'])
 
-        self.assert_list_configs(self.user1, ['b2', 'c3'])
+        self.assert_list_config_names(self.user1, ['b2', 'c3'])
 
     def test_list_configs_when_none_allowed(self):
         _create_script_config_file('a1', allowed_users=['XYZ'])
         _create_script_config_file('b2', allowed_users=['ABC'])
 
-        self.assert_list_configs(self.user1, [])
+        self.assert_list_config_names(self.user1, [])
 
     def test_load_config_when_user_allowed(self):
         _create_script_config_file('my_script', allowed_users=['ABC', 'user1', 'qwerty'])
@@ -125,7 +138,7 @@ def test_load_config_when_user_not_allowed(self):
 
         self.assertRaises(ConfigNotAllowedException, self.config_service.load_config_model, 'my_script', self.user1)
 
-    def assert_list_configs(self, user, expected_names):
+    def assert_list_config_names(self, user, expected_names):
         configs = self.config_service.list_configs(user)
         conf_names = [config.name for config in configs]
         self.assertCountEqual(expected_names, conf_names)
diff --git a/src/tests/model_helper_test.py b/src/tests/model_helper_test.py
index 1c479a01..1dce2d40 100644
--- a/src/tests/model_helper_test.py
+++ b/src/tests/model_helper_test.py
@@ -341,6 +341,22 @@ def test_text_with_whitespaces(self):
         value = read_str_from_config({'key1': '  xyz  \n'}, 'key1')
         self.assertEquals('  xyz  \n', value)
 
+    def test_text_when_blank_to_none_and_none(self):
+        value = read_str_from_config({'key1': None}, 'key1', blank_to_none=True)
+        self.assertIsNone(value)
+
+    def test_text_when_blank_to_none_and_empty(self):
+        value = read_str_from_config({'key1': ''}, 'key1', blank_to_none=True)
+        self.assertIsNone(value)
+
+    def test_text_when_blank_to_none_and_blank(self):
+        value = read_str_from_config({'key1': ' \t \n'}, 'key1', blank_to_none=True)
+        self.assertIsNone(value)
+
+    def test_text_when_blank_to_none_and_blank_and_default(self):
+        value = read_str_from_config({'key1': ' \t \n'}, 'key1', blank_to_none=True, default='abc')
+        self.assertEquals('abc', value)
+
     def test_text_when_int(self):
         self.assertRaisesRegex(InvalidValueTypeException, 'Invalid key1 value: string expected, but was: 5',
                                read_str_from_config, {'key1': 5}, 'key1')
diff --git a/src/tests/web/server_test.py b/src/tests/web/server_test.py
index df632756..66ef9e4f 100644
--- a/src/tests/web/server_test.py
+++ b/src/tests/web/server_test.py
@@ -1,3 +1,4 @@
+import os
 import threading
 import traceback
 from asyncio import set_event_loop_policy
@@ -7,6 +8,8 @@
 import requests
 from tornado.ioloop import IOLoop
 
+from auth.authorization import Authorizer, ANY_USER, EmptyGroupProvider
+from config.config_service import ConfigService
 from features.file_download_feature import FileDownloadFeature
 from files.user_file_storage import UserFileStorage
 from model.server_conf import ServerConfig
@@ -71,26 +74,46 @@ def test_init_when_windows_and_python_3_7(self):
 
             raise
 
+    def test_get_scripts(self):
+        self.start_server(12345, '127.0.0.1')
+
+        test_utils.write_script_config({'name': 's1'}, 's1', self.runners_folder)
+        test_utils.write_script_config({'name': 's2', 'group': 'Xyz'}, 's2', self.runners_folder)
+        test_utils.write_script_config({'name': 's3'}, 's3', self.runners_folder)
+
+        response = self.request('GET', 'http://127.0.0.1:12345/scripts')
+        self.assertCountEqual([
+            {'name': 's1', 'group': None},
+            {'name': 's2', 'group': 'Xyz'},
+            {'name': 's3', 'group': None}],
+            response['scripts'])
+
+    def request(self, method, url):
+        response = requests.request(method, url)
+        self.assertEqual(200, response.status_code, 'Failed to execute request: ' + response.text)
+        return response.json()
+
     def check_server_running(self):
         response = requests.get('http://127.0.0.1:12345/conf')
         self.assertEqual(response.status_code, 200)
 
     def start_server(self, port, address):
-        file_download_feature = FileDownloadFeature(UserFileStorage(b'123456'), test_utils.temp_folder)
+        file_download_feature = FileDownloadFeature(UserFileStorage(b'some_secret'), test_utils.temp_folder)
         config = ServerConfig()
         config.port = port
         config.address = address
 
+        authorizer = Authorizer(ANY_USER, [], [], EmptyGroupProvider())
         server.init(config,
                     None,
+                    authorizer,
                     None,
                     None,
-                    None,
-                    None,
+                    ConfigService(authorizer, self.conf_folder),
                     None,
                     None,
                     file_download_feature,
-                    None,
+                    'cookie_secret',
                     None,
                     start_server=False)
         self.start_loop()
@@ -107,6 +130,9 @@ def setUp(self) -> None:
         self.requires_explicit_ioloop_factory = os_utils.is_win() and env_utils.is_min_version('3.8')
         self.windows = os_utils.is_win()
 
+        self.conf_folder = test_utils.create_dir(os.path.join('conf'))
+        self.runners_folder = os.path.join(self.conf_folder, 'runners')
+
     def tearDown(self) -> None:
         super().tearDown()
 
diff --git a/src/web/server.py b/src/web/server.py
index c85584f9..57de37bc 100755
--- a/src/web/server.py
+++ b/src/web/server.py
@@ -195,9 +195,9 @@ class GetScripts(BaseRequestHandler):
     def get(self, user):
         configs = self.application.config_service.list_configs(user)
 
-        names = [conf.name for conf in configs]
+        scripts = [{'name': conf.name, 'group': conf.group} for conf in configs]
 
-        self.write(json.dumps(names))
+        self.write(json.dumps({'scripts': scripts}))
 
 
 class AdminUpdateScriptEndpoint(BaseRequestHandler):
diff --git a/web-src/js/admin/AdminApp.vue b/web-src/js/admin/AdminApp.vue
index 9cac5167..1ee1f8bb 100644
--- a/web-src/js/admin/AdminApp.vue
+++ b/web-src/js/admin/AdminApp.vue
@@ -34,7 +34,7 @@
         modules: {
             'history': executions(),
             scripts: scripts,
-            'script-config': scriptConfig
+            scriptConfig: scriptConfig
         },
         actions: {
             setSubheader({commit}, subheader) {
diff --git a/web-src/js/admin/scripts-config/ScriptConfig.vue b/web-src/js/admin/scripts-config/ScriptConfig.vue
index e1ca78a5..4d42b318 100644
--- a/web-src/js/admin/scripts-config/ScriptConfig.vue
+++ b/web-src/js/admin/scripts-config/ScriptConfig.vue
@@ -33,11 +33,11 @@
         },
 
         methods: {
-            ...mapActions('script-config', ['init', 'save'])
+            ...mapActions('scriptConfig', ['init', 'save'])
         },
 
         computed: {
-            ...mapState('script-config', {
+            ...mapState('scriptConfig', {
                 scriptConfig: 'scriptConfig',
                 loadingError: 'error'
             })
diff --git a/web-src/js/admin/scripts-config/ScriptConfigForm.vue b/web-src/js/admin/scripts-config/ScriptConfigForm.vue
index 862470a4..9f351932 100644
--- a/web-src/js/admin/scripts-config/ScriptConfigForm.vue
+++ b/web-src/js/admin/scripts-config/ScriptConfigForm.vue
@@ -2,6 +2,7 @@
     <form class="script-config-form col">
         <div class="row">
             <TextField :config="nameField" class="col s6" v-model="newName"/>
+            <TextField :config="groupField" class="col s5 offset-s1" v-model="group"/>
         </div>
         <div class="row">
             <TextField :config="scriptPathField" class="col s6" v-model="scriptPath"/>
@@ -33,13 +34,14 @@
     import _ from 'lodash';
     import {forEachKeyValue, isEmptyArray, isEmptyString, isNull} from '../../common';
     import CheckBox from '../../components/checkbox'
+    import ChipsList from '../../components/ChipsList';
     import TextArea from '../../components/TextArea';
     import TextField from '../../components/textfield'
-    import ChipsList from '../../components/ChipsList';
     import {
         allowAllField,
         bashFormattingField,
         descriptionField,
+        groupField,
         includeScriptField,
         nameField,
         requiresTerminalField,
@@ -62,6 +64,7 @@
             return {
                 configCopy: null,
                 newName: null,
+                group: null,
                 scriptPath: null,
                 description: null,
                 workingDirectory: null,
@@ -71,6 +74,7 @@
                 allowedUsers: [],
                 allowAllUsers: true,
                 nameField,
+                groupField,
                 scriptPathField,
                 workDirField,
                 descriptionField,
@@ -84,6 +88,7 @@
         mounted: function () {
             const simpleFields = {
                 'newName': 'name',
+                'group': 'group',
                 'scriptPath': 'script_path',
                 'description': 'description',
                 'workingDirectory': 'working_directory',
@@ -108,6 +113,7 @@
                 immediate: true,
                 handler(config) {
                     this.newName = config.name;
+                    this.group = config.group;
                     this.scriptPath = config['script_path'];
                     this.description = config['description'];
                     this.workingDirectory = config['working_directory'];
diff --git a/web-src/js/admin/scripts-config/script-fields.js b/web-src/js/admin/scripts-config/script-fields.js
index a5266506..ecab72c9 100644
--- a/web-src/js/admin/scripts-config/script-fields.js
+++ b/web-src/js/admin/scripts-config/script-fields.js
@@ -2,6 +2,10 @@ export const nameField = {
     name: 'Script name',
     required: true
 };
+export const groupField = {
+    name: 'Group',
+    description: 'Aggregates scripts from the same group into the same category on UI'
+};
 export const scriptPathField = {
     name: 'Script path',
     required: true
diff --git a/web-src/js/admin/scripts-config/scripts-module.js b/web-src/js/admin/scripts-config/scripts-module.js
index 6aeac81b..d8f44d56 100644
--- a/web-src/js/admin/scripts-config/scripts-module.js
+++ b/web-src/js/admin/scripts-config/scripts-module.js
@@ -1,5 +1,8 @@
 import axios from 'axios';
 
+
+export const axiosInstance = axios.create();
+
 export default {
     state: {
         scripts: [],
@@ -10,14 +13,16 @@ export default {
         init({commit}) {
             commit('SET_LOADING', true);
 
-            axios.get('scripts').then(({data: scripts}) => {
-                scripts.sort(function (name1, name2) {
+            axiosInstance.get('scripts').then(({data}) => {
+                const {scripts} = data;
+                let scriptNames = scripts.map(s => s.name);
+                scriptNames.sort(function (name1, name2) {
                     return name1.toLowerCase().localeCompare(name2.toLowerCase());
                 });
 
-                commit('SET_SCRIPTS', scripts);
+                commit('SET_SCRIPTS', scriptNames);
                 commit('SET_LOADING', false);
-            });
+            })
         }
     },
     mutations: {
diff --git a/web-src/js/main-app/scripts/ScriptListGroup.vue b/web-src/js/main-app/scripts/ScriptListGroup.vue
new file mode 100644
index 00000000..ee375a40
--- /dev/null
+++ b/web-src/js/main-app/scripts/ScriptListGroup.vue
@@ -0,0 +1,55 @@
+<template>
+    <div class="script-list-group" :class="{active:group.isActive}">
+        <a class="collection-item waves-effect waves-teal script-group"
+           :key="group.name"
+           @click="$emit('group-clicked', group.name)">
+            <span>{{group.name}}</span>
+            <i class="material-icons">
+                {{ group.isActive ? 'expand_less' : 'expand_more'}}
+            </i>
+        </a>
+
+        <ScriptListItem :script="innerScript"
+                        v-for="innerScript in group.scripts" :key="innerScript.name"
+                        v-if="group.isActive"/>
+    </div>
+</template>
+
+<script>
+    import ScriptListItem from './ScriptListItem';
+
+    export default {
+        name: 'ScriptListGroup',
+        components: {ScriptListItem},
+        props: {
+            group: {
+                type: Object
+            }
+        }
+    }
+</script>
+
+<style scoped>
+
+    .script-list-group .collection-item.script-group {
+        border: none;
+        display: flex;
+        flex-direction: row;
+        padding-right: 16px;
+        align-items: center;
+    }
+
+    .script-list-group .collection-item.script-group span {
+        flex: 1 1 auto;
+    }
+
+    .script-list-group .collection-item.script-group i {
+        flex: 0 0 auto;
+        line-height: 16px;
+    }
+
+    .script-list-group >>> .collection-item.script-list-item {
+        padding-left: 36px;
+    }
+
+</style>
\ No newline at end of file
diff --git a/web-src/js/main-app/scripts/ScriptListItem.vue b/web-src/js/main-app/scripts/ScriptListItem.vue
new file mode 100644
index 00000000..cfd800c7
--- /dev/null
+++ b/web-src/js/main-app/scripts/ScriptListItem.vue
@@ -0,0 +1,129 @@
+<template>
+    <router-link :to="'/' + descriptor.hash"
+                 class="collection-item waves-effect waves-teal script-list-item"
+                 v-bind:class="{ active: descriptor.active}">
+        {{ descriptor.name }}
+
+        <div :class="descriptor.state" class="menu-item-state">
+            <i class="material-icons check-icon">check</i>
+            <div class="preloader-wrapper active">
+                <div class="spinner-layer">
+                    <div class="circle-clipper left">
+                        <div class="circle"></div>
+                    </div>
+                    <div class="gap-patch">
+                        <div class="circle"></div>
+                    </div>
+                    <div class="circle-clipper right">
+                        <div class="circle"></div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </router-link>
+
+</template>
+
+<script>
+    import {mapState} from 'vuex';
+    import {forEachKeyValue} from '../../common';
+    import {scriptNameToHash} from '../model_helper';
+
+    export default {
+        name: 'ScriptListItem',
+        props: {
+            script: {
+                type: Object,
+                default: null
+            }
+        },
+        computed: {
+            descriptor() {
+                return {
+                    name: this.script.name,
+                    state: this.getState(this.script.name),
+                    active: this.selectedScript === this.script.name,
+                    hash: this.toHash(this.script.name)
+                }
+            },
+            ...mapState('scripts', ['selectedScript'])
+        },
+        methods: {
+            getState(scriptName) {
+                let state = 'idle';
+
+                forEachKeyValue(this.$store.state.executions.executors, function (id, executor) {
+                    if (executor.state.scriptName !== scriptName) {
+                        return;
+                    }
+
+                    state = executor.state.status;
+                });
+
+                return state;
+            },
+            toHash: scriptNameToHash
+        }
+    }
+</script>
+
+<style scoped>
+    .scripts-list .collection-item {
+        border: none;
+        padding-right: 32px;
+    }
+
+    .scripts-list .collection-item .menu-item-state {
+        width: 24px;
+        height: 24px;
+        position: absolute;
+        right: 16px;
+        top: calc(50% - 12px);
+        display: none;
+    }
+
+    .scripts-list .collection-item .menu-item-state > .check-icon {
+        color: #26a69a;
+        display: none;
+        font-size: 24px;
+    }
+
+    .scripts-list .collection-item.active .menu-item-state > .check-icon {
+        color: white;
+    }
+
+    .scripts-list .collection-item .menu-item-state > .preloader-wrapper {
+        display: none;
+        width: 100%;
+        height: 100%;
+    }
+
+    .scripts-list .collection-item .menu-item-state.executing,
+    .scripts-list .collection-item .menu-item-state.finished {
+        display: inline;
+    }
+
+    .scripts-list .collection-item .menu-item-state.executing > .check-icon {
+        display: none;
+    }
+
+    .scripts-list .collection-item .menu-item-state.executing > .preloader-wrapper {
+        display: block;
+    }
+
+    .scripts-list .collection-item .menu-item-state.finished > .check-icon {
+        display: block;
+    }
+
+    .scripts-list .collection-item .menu-item-state.finished > .preloader-wrapper {
+        display: none;
+    }
+
+    .scripts-list .collection-item.active .preloader-wrapper .spinner-layer {
+        border-color: white;
+    }
+
+    .scripts-list .collection-item .preloader-wrapper .spinner-layer {
+        border-color: #26a69a;
+    }
+</style>
\ No newline at end of file
diff --git a/web-src/js/main-app/scripts/ScriptsList.vue b/web-src/js/main-app/scripts/ScriptsList.vue
index 6a07ae25..e388f546 100644
--- a/web-src/js/main-app/scripts/ScriptsList.vue
+++ b/web-src/js/main-app/scripts/ScriptsList.vue
@@ -1,39 +1,21 @@
 <template>
-    <div class="scripts-list collection">
-        <router-link :to="'/' + script.hash"
-                     class="collection-item waves-effect waves-teal"
-                     v-bind:class="{ active: script.active}"
-                     v-for="script in scriptDescriptors">
-            {{ script.name }}
-
-            <div :class="script.state" class="menu-item-state">
-                <i class="material-icons check-icon">check</i>
-                <div class="preloader-wrapper active">
-                    <div class="spinner-layer">
-                        <div class="circle-clipper left">
-                            <div class="circle"></div>
-                        </div>
-                        <div class="gap-patch">
-                            <div class="circle"></div>
-                        </div>
-                        <div class="circle-clipper right">
-                            <div class="circle"></div>
-                        </div>
-                    </div>
-                </div>
-            </div>
-        </router-link>
+    <div class="scripts-list collection" ref="scriptList">
+        <template v-for="item in items">
+            <ScriptListGroup v-if="item.isGroup" :group="item" :key="item.name" @group-clicked="groupClicked($event)"/>
+            <ScriptListItem v-else :script="item" :key="item.name"/>
+        </template>
     </div>
 </template>
 
 <script>
     import {mapState} from 'vuex';
-    import {forEachKeyValue, isEmptyString} from '../../common';
-    import {scriptNameToHash} from '../model_helper';
+    import {isBlankString, isEmptyString, isNull, removeElement} from '../../common';
+    import ScriptListGroup from './ScriptListGroup';
+    import ScriptListItem from './ScriptListItem';
 
     export default {
         name: 'ScriptsList',
-
+        components: {ScriptListGroup, ScriptListItem},
         props: {
             searchText: {
                 type: String,
@@ -41,41 +23,69 @@
             }
         },
 
+        data: function () {
+            return {
+                activeGroup: null
+            }
+        },
+
         computed: {
-            ...mapState('scripts', {
-                scripts: 'scripts',
-                selectedScript: 'selectedScript'
-            }),
+            ...mapState('scripts', ['scripts', 'selectedScript']),
+
+            items() {
+                let groups = this.scripts.filter(script => !isBlankString(script.group))
+                    .map(script => script.group)
+                    .filter((v, i, a) => a.indexOf(v) === i) // unique elements
+                    .map(group => ({name: group, isGroup: true, scripts: [], isActive: this.activeGroup === group}));
 
-            scriptDescriptors() {
-                return this.scripts
-                    .map(scriptName => {
-                        return {
-                            name: scriptName,
-                            state: this.getState(scriptName),
-                            active: this.selectedScript === scriptName,
-                            hash: this.toHash(scriptName)
-                        }
-                    })
-                    .filter(d =>
-                        isEmptyString(this.searchText) || (d.name.toLowerCase().includes(this.searchText.toLowerCase())))
+                let foundScripts = this.scripts
+                    .filter(script =>
+                        isEmptyString(this.searchText) || (script.name.toLowerCase().includes(this.searchText.toLowerCase())));
+
+                for (const script of foundScripts.slice()) {
+                    if (isBlankString(script.group)) {
+                        continue;
+                    }
+                    let foundGroup = groups.find(g => g.name === script.group);
+                    foundGroup.scripts.push(script);
+                    removeElement(foundScripts, script);
+                }
+
+                const result = foundScripts.concat(groups);
+                result.sort((o1, o2) => o1.name.toLowerCase().localeCompare(o2.name.toLowerCase()));
+
+                return result;
             }
         },
         methods: {
-            toHash: scriptNameToHash,
-
-            getState(scriptName) {
-                let state = 'idle';
+            groupClicked(groupName) {
+                if (isNull(groupName) || (this.activeGroup === groupName)) {
+                    this.activeGroup = null;
+                    return;
+                }
+                this.activeGroup = groupName;
+            }
+        },
+        watch: {
+            selectedScript: {
+                immediate: true,
+                handler(selectedScript) {
+                    if (isNull(selectedScript)) {
+                        return;
+                    }
 
-                forEachKeyValue(this.$store.state.executions.executors, function (id, executor) {
-                    if (executor.state.scriptName !== scriptName) {
+                    let foundScript = this.scripts.find(script => script.name === selectedScript);
+                    if (isNull(foundScript) || isNull(foundScript.group)) {
                         return;
                     }
 
-                    state = executor.state.status;
-                });
+                    let group = this.items.find(item => item.isGroup && (item.name === foundScript.group));
+                    if (isNull(group) || group.isActive) {
+                        return;
+                    }
 
-                return state;
+                    this.activeGroup = group.name;
+                }
             }
         }
     }
@@ -91,63 +101,4 @@
         flex-grow: 1;
     }
 
-    .scripts-list .collection-item {
-        border: none;
-        padding-right: 32px;
-    }
-
-    .scripts-list .collection-item .menu-item-state {
-        width: 24px;
-        height: 24px;
-        position: absolute;
-        right: 8px;
-        top: calc(50% - 12px);
-        display: none;
-    }
-
-    .scripts-list .collection-item .menu-item-state > .check-icon {
-        color: #26a69a;
-        display: none;
-        font-size: 24px;
-    }
-
-    .scripts-list .collection-item.active .menu-item-state > .check-icon {
-        color: white;
-    }
-
-    .scripts-list .collection-item .menu-item-state > .preloader-wrapper {
-        display: none;
-        width: 100%;
-        height: 100%;
-    }
-
-    .scripts-list .collection-item .menu-item-state.executing,
-    .scripts-list .collection-item .menu-item-state.finished {
-        display: inline;
-    }
-
-    .scripts-list .collection-item .menu-item-state.executing > .check-icon {
-        display: none;
-    }
-
-    .scripts-list .collection-item .menu-item-state.executing > .preloader-wrapper {
-        display: block;
-    }
-
-    .scripts-list .collection-item .menu-item-state.finished > .check-icon {
-        display: block;
-    }
-
-    .scripts-list .collection-item .menu-item-state.finished > .preloader-wrapper {
-        display: none;
-    }
-
-    .scripts-list .collection-item.active .preloader-wrapper .spinner-layer {
-        border-color: white;
-    }
-
-    .scripts-list .collection-item .preloader-wrapper .spinner-layer {
-        border-color: #26a69a;
-    }
-
 </style>
\ No newline at end of file
diff --git a/web-src/js/main-app/store/scripts.js b/web-src/js/main-app/store/scripts.js
index 2298acb4..59b5e712 100644
--- a/web-src/js/main-app/store/scripts.js
+++ b/web-src/js/main-app/store/scripts.js
@@ -20,9 +20,10 @@ export default {
             });
 
             axios.get('scripts')
-                .then(({data: scripts}) => {
-                    scripts.sort(function (name1, name2) {
-                        return name1.toLowerCase().localeCompare(name2.toLowerCase());
+                .then(({data}) => {
+                    const {scripts} = data;
+                    scripts.sort(function (script1, script2) {
+                        return script1.name.toLowerCase().localeCompare(script2.name.toLowerCase());
                     });
 
                     commit('SET_SCRIPTS', scripts);
@@ -44,9 +45,9 @@ export default {
             let newSelectedScript = null;
 
             for (const script of state.scripts) {
-                const scriptHash = scriptNameToHash(script);
+                const scriptHash = scriptNameToHash(script.name);
                 if (scriptHash === encodedScriptName) {
-                    newSelectedScript = script;
+                    newSelectedScript = script.name;
                     break;
                 }
             }
diff --git a/web-src/package.json b/web-src/package.json
index d7fdf1a3..747d6857 100644
--- a/web-src/package.json
+++ b/web-src/package.json
@@ -3,7 +3,7 @@
   "version": "1.15.0",
   "dependencies": {
     "@babel/runtime": "^7.7.7",
-    "axios": "^0.19.0",
+    "axios": "^0.19.2",
     "jquery": "^3.4.1",
     "marked": "^0.7.0",
     "material-design-icons": "^3.0.1",
@@ -25,7 +25,7 @@
     "@stryker-mutator/webpack-transpiler": "^1.3.1",
     "@vue/test-utils": "1.0.0-beta.29",
     "axios-mock-adapter": "^1.17.0",
-    "babel-loader": "^8.0.6",
+    "babel-loader": "^8.1.0",
     "babel-plugin-rewire": "^1.2.0",
     "chai": "^4.2.0",
     "copy-webpack-plugin": "^4.6.0",
diff --git a/web-src/tests/admin/ParameterConfigForm_test.js b/web-src/tests/admin/ParameterConfigForm_test.js
index aadffa8b..6f8e0f71 100644
--- a/web-src/tests/admin/ParameterConfigForm_test.js
+++ b/web-src/tests/admin/ParameterConfigForm_test.js
@@ -2,9 +2,9 @@
 
 import {mount} from '@vue/test-utils';
 import {assert, config as chaiConfig} from 'chai';
-import ChipsList from '../../js/components/ChipsList';
 import ParameterConfigForm from '../../js/admin/scripts-config/ParameterConfigForm';
 import {isBlankString, isNull, setInputValue} from '../../js/common';
+import ChipsList from '../../js/components/ChipsList';
 import Combobox from '../../js/components/combobox';
 import TextArea from '../../js/components/TextArea';
 import {setChipListValue, vueTicks} from '../test_utils';
@@ -26,7 +26,7 @@ export async function setValueByUser(form, parameterName, value) {
     await vueTicks();
 }
 
-const findField = (form, expectedName, failOnMissing = true) => {
+export const findField = (form, expectedName, failOnMissing = true) => {
     for (const child of form.$children) {
         let fieldName;
         if (child.$options._componentTag === ChipsList.name) {
diff --git a/web-src/tests/admin/ParameterList_test.js b/web-src/tests/admin/ParameterList_test.js
index bc50d6c1..8a268a1c 100644
--- a/web-src/tests/admin/ParameterList_test.js
+++ b/web-src/tests/admin/ParameterList_test.js
@@ -10,7 +10,7 @@ import {setValueByUser} from './ParameterConfigForm_test';
 
 chaiConfig.truncateThreshold = 0;
 
-describe('Test ScriptParamList 2', function () {
+describe('Test ScriptParamList', function () {
     let list;
     let errors;
 
diff --git a/web-src/tests/admin/ScriptConfig_test.js b/web-src/tests/admin/ScriptConfig_test.js
new file mode 100644
index 00000000..81a560c7
--- /dev/null
+++ b/web-src/tests/admin/ScriptConfig_test.js
@@ -0,0 +1,103 @@
+'use strict';
+
+import {createLocalVue, mount} from '@vue/test-utils';
+import {assert, config as chaiConfig} from 'chai';
+import Vuex from 'vuex';
+import ScriptConfig from '../../js/admin/scripts-config/ScriptConfig';
+import ScriptConfigForm from '../../js/admin/scripts-config/ScriptConfigForm';
+import {vueTicks} from '../test_utils';
+import {findField, setValueByUser} from './ParameterConfigForm_test';
+
+
+chaiConfig.truncateThreshold = 0;
+
+const localVue = createLocalVue();
+localVue.use(Vuex);
+
+describe('Test ScriptConfig', function () {
+    let store;
+    let configComponent;
+
+    beforeEach(async function () {
+        store = new Vuex.Store({
+            modules: {
+                scriptConfig: {
+                    namespaced: true,
+                    state: {
+                        scriptName: 'test_script',
+                        scriptConfig: {'name': 'test_script'}
+                    },
+                    actions: {
+                        init({commit, state}, scriptName) {
+
+                        },
+
+                        save({dispatch, state}) {
+
+                        }
+                    }
+                }
+            }
+        });
+
+        configComponent = mount(ScriptConfig, {
+            store,
+            localVue,
+            attachToDocument: true,
+            propsData: {scriptName: 'script1'}
+        });
+
+        await vueTicks();
+    });
+
+    afterEach(async function () {
+        await vueTicks();
+
+        configComponent.destroy();
+    });
+
+    const _findField = (expectedName, failOnMissing = true) => {
+        const form = configComponent.find(ScriptConfigForm);
+        return findField(form.vm, expectedName, failOnMissing);
+    };
+
+    async function _setValueByUser(fieldName, value) {
+        const form = configComponent.find(ScriptConfigForm);
+        await setValueByUser(form.vm, fieldName, value);
+    }
+
+    describe('Test show config', function () {
+        it('Test show simple values', async function () {
+            store.state.scriptConfig.scriptConfig = {
+                'name': 's1',
+                'group': 'important',
+                'script_path': 'ping',
+                'description': 'some desc',
+                'working_directory': '/home',
+                'requires_terminal': true,
+                'include': 'script.json',
+                'bash_formatting': false
+            };
+
+            await vueTicks();
+
+            assert.equal('s1', _findField('Script name').value);
+            assert.equal('important', _findField('Group').value);
+            assert.equal('ping', _findField('Script path').value);
+            assert.equal('some desc', _findField('Description').value);
+            assert.equal('/home', _findField('Working directory').value);
+            assert.equal(true, _findField('Requires terminal').value);
+            assert.equal('script.json', _findField('Include config').value);
+            assert.equal(false, _findField('Bash formatting').value);
+        });
+    });
+
+    describe('Test edit config', function () {
+        it('Test edit group', async function () {
+            await _setValueByUser('Group', 'xyz');
+
+            assert.equal('xyz', store.state.scriptConfig.scriptConfig.group);
+        });
+    });
+
+});
\ No newline at end of file
diff --git a/web-src/tests/admin/script-module_test.js b/web-src/tests/admin/script-module_test.js
new file mode 100644
index 00000000..987aabaa
--- /dev/null
+++ b/web-src/tests/admin/script-module_test.js
@@ -0,0 +1,56 @@
+'use strict';
+import {createLocalVue} from '@vue/test-utils';
+import MockAdapter from 'axios-mock-adapter';
+import {assert, config as chaiConfig} from 'chai';
+import Vuex from 'vuex';
+import scripts, {axiosInstance} from '../../js/admin/scripts-config/scripts-module'
+
+chaiConfig.truncateThreshold = 0;
+
+const localVue = createLocalVue();
+localVue.use(Vuex);
+
+const axiosMock = new MockAdapter(axiosInstance);
+const flushPromises = () => new Promise(resolve => setTimeout(resolve));
+
+
+function mockGetScripts(scripts) {
+    axiosMock.onGet('scripts')
+        .reply(200, {scripts});
+}
+
+describe('Test admin script module', function () {
+    let store;
+
+    beforeEach(async function () {
+        store = new Vuex.Store({
+            modules: {
+                scripts: scripts
+            }
+        });
+    });
+
+    describe('Test load scripts', function () {
+
+            it('test load single script', async function () {
+                mockGetScripts([{'name': 'script1'}]);
+
+                await store.dispatch('scripts/init');
+                await flushPromises();
+
+                assert.deepEqual(store.state.scripts.scripts, ['script1']);
+                assert.isFalse(store.state.scripts.loading);
+            });
+
+            it('test load multiple unsorted scripts', async function () {
+                mockGetScripts([{'name': 'def', 'group': 'some_group'}, {'name': 'xyz'}, {'name': 'abc'}]);
+
+                await store.dispatch('scripts/init');
+                await flushPromises();
+
+                assert.deepEqual(store.state.scripts.scripts, ['abc', 'def', 'xyz']);
+                assert.isFalse(store.state.scripts.loading);
+            });
+        }
+    )
+});
diff --git a/web-src/tests/main-app/scripts/ScriptList_test.js b/web-src/tests/main-app/scripts/ScriptList_test.js
new file mode 100644
index 00000000..6847a5fa
--- /dev/null
+++ b/web-src/tests/main-app/scripts/ScriptList_test.js
@@ -0,0 +1,271 @@
+'use strict';
+
+import {createLocalVue, mount} from '@vue/test-utils';
+import {assert, config as chaiConfig} from 'chai';
+import VueRouter from 'vue-router';
+import Vuex from 'vuex';
+import {hasClass, isBlankString} from '../../../js/common';
+import router from '../../../js/main-app/router';
+import ScriptsList from '../../../js/main-app/scripts/ScriptsList';
+import {triggerSingleClick, vueTicks} from '../../test_utils';
+
+
+chaiConfig.truncateThreshold = 0;
+
+const localVue = createLocalVue();
+localVue.use(Vuex);
+localVue.use(VueRouter);
+
+describe('Test ScriptConfig', function () {
+    let store;
+    let listComponent;
+
+    beforeEach(async function () {
+        store = new Vuex.Store({
+            modules: {
+                scripts: {
+                    namespaced: true,
+                    state: {
+                        scripts: [],
+                        selectedScript: null
+                    }
+                },
+                executions: {
+                    executors: {}
+                }
+            }
+        });
+
+        listComponent = mount(ScriptsList, {
+            store,
+            localVue,
+            router,
+            attachToDocument: true
+        });
+
+        await vueTicks();
+    });
+
+    afterEach(async function () {
+        await vueTicks();
+
+        listComponent.destroy();
+    });
+
+    function getText(item) {
+        return Array.from(item.childNodes)
+            .filter(child => child.nodeType === 3)
+            .map(child => child.nodeValue.trim())
+            .reduce((left, right) => left + right);
+    }
+
+    function getGroupText(groupItem) {
+        let groupTextItem = $(groupItem).find('> .script-group > span').get(0);
+        return getText(groupTextItem);
+    }
+
+    function getTopLevelItems() {
+        return Array.from(listComponent.vm.$el.childNodes)
+            .filter(child => hasClass(child, 'collection-item') || hasClass(child, 'script-list-group'))
+            .map(child => {
+                if (hasClass(child, 'script-list-group')) {
+                    return getGroupText(child);
+                }
+
+                return getText(child);
+            });
+    }
+
+    function findGroupItem(groupName) {
+        let foundGroups = $(listComponent.vm.$el).find('.script-list-group').has('.script-group > span:contains("' + groupName + '")');
+        if (foundGroups.length > 1) {
+            assert.fail('More than 1 group item found: ' + groupName);
+        } else if (foundGroups.length === 0) {
+            assert.fail('Group item not found: ' + groupName);
+        }
+        return foundGroups.get(0);
+    }
+
+    function assertGroupItems(groupName, expectedTexts) {
+        let foundGroup = findGroupItem(groupName);
+
+        let innerItems = $(foundGroup).find('.collection-item:not(.script-group)').toArray();
+        let actualTexts = innerItems.map(item => getText(item));
+        assert.deepEqual(actualTexts, expectedTexts);
+    }
+
+    function assertOpenGroup(expectedOpenGroup, expectedItems) {
+        if (!isBlankString(expectedOpenGroup)) {
+            assertGroupItems(expectedOpenGroup, expectedItems);
+        }
+
+        let groupItems = $(listComponent.vm.$el).find('.script-list-group').toArray();
+        for (const groupItem of groupItems) {
+            let itemName = getGroupText(groupItem);
+            if (itemName === expectedOpenGroup) {
+                continue;
+            }
+
+            assertGroupItems(itemName, []);
+        }
+    }
+
+    async function clickOnGroup(groupName) {
+        let dropdownItem = $(findGroupItem(groupName)).find('.script-group');
+        triggerSingleClick(dropdownItem.get(0));
+
+        await vueTicks();
+    }
+
+    describe('Test show list', function () {
+        it('Test show single item', async function () {
+            store.state.scripts.scripts = [{'name': 'abc'}];
+
+            await vueTicks();
+
+            let texts = getTopLevelItems();
+
+            assert.deepEqual(texts, ['abc']);
+        });
+
+        it('Test show multiple items', async function () {
+            store.state.scripts.scripts = [{'name': 'abc'}, {'name': 'xyz'}, {'name': 'def'}];
+
+            await vueTicks();
+
+            let texts = getTopLevelItems();
+
+            assert.deepEqual(texts, ['abc', 'def', 'xyz']);
+        });
+
+        it('Test show single item in group', async function () {
+            store.state.scripts.scripts = [{'name': 'abc', 'group': 'g1'}];
+
+            await vueTicks();
+
+            let texts = getTopLevelItems();
+
+            assert.deepEqual(texts, ['g1']);
+        });
+
+        it('Test show multiple items in different groups', async function () {
+            store.state.scripts.scripts = [
+                {'name': 'abc', 'group': 'g3'},
+                {'name': 'xyz', 'group': 'g2'},
+                {'name': 'def', 'group': 'g1'}];
+
+            await vueTicks();
+
+            let texts = getTopLevelItems();
+
+            assert.deepEqual(texts, ['g1', 'g2', 'g3']);
+        });
+
+        it('Test show multiple items in different groups when empty', async function () {
+            store.state.scripts.scripts = [
+                {'name': 'abc', 'group': null},
+                {'name': 'xyz', 'group': ''},
+                {'name': 'def', 'group': ' \n'}];
+
+            await vueTicks();
+
+            let texts = getTopLevelItems();
+
+            assert.deepEqual(texts, ['abc', 'def', 'xyz']);
+        });
+
+        it('Test show multiple items in same groups', async function () {
+            store.state.scripts.scripts = [
+                {'name': 'abc', 'group': 'g3'},
+                {'name': 'ghi', 'group': 'g1'},
+                {'name': 'xyz', 'group': 'g2'},
+                {'name': 'jkl', 'group': 'g2'},
+                {'name': 'def', 'group': 'g1'}];
+
+            await vueTicks();
+
+            let texts = getTopLevelItems();
+
+            assert.deepEqual(texts, ['g1', 'g2', 'g3']);
+        });
+
+        it('Test show items and groups mixed', async function () {
+            store.state.scripts.scripts = [
+                {'name': 'abc', 'group': 'g3'},
+                {'name': 'ghi'},
+                {'name': 'xyz', 'group': 'g2'},
+                {'name': 'jkl', 'group': 'g2'},
+                {'name': 'def'}];
+
+            await vueTicks();
+
+            let texts = getTopLevelItems();
+
+            assert.deepEqual(texts, ['def', 'g2', 'g3', 'ghi']);
+        });
+    });
+
+    describe('Test open groups', function () {
+        it('Test nothing open by default', async function () {
+            store.state.scripts.scripts = [
+                {'name': 'abc', 'group': 'g3'},
+                {'name': 'xyz', 'group': 'g2'},
+                {'name': 'def', 'group': 'g1'}];
+
+            await vueTicks();
+
+            assertOpenGroup(null);
+        });
+
+        it('Test open by default when selected', async function () {
+            store.state.scripts.scripts = [
+                {'name': 'abc', 'group': 'g3'},
+                {'name': 'xyz', 'group': 'g2'},
+                {'name': 'def', 'group': 'g1'}];
+            store.state.scripts.selectedScript = 'abc';
+
+            await vueTicks();
+
+            assertOpenGroup('g3', ['abc']);
+        });
+
+        it('Test open on click', async function () {
+            store.state.scripts.scripts = [
+                {'name': 'abc', 'group': 'g3'},
+                {'name': 'def', 'group': 'g2'},
+                {'name': 'xyz', 'group': 'g2'}];
+
+            await vueTicks();
+            await clickOnGroup('g2');
+
+            assertOpenGroup('g2', ['def', 'xyz']);
+        });
+
+        it('Test open another group on click', async function () {
+            store.state.scripts.scripts = [
+                {'name': 'abc', 'group': 'g3'},
+                {'name': 'def', 'group': 'g2'},
+                {'name': 'xyz', 'group': 'g2'}];
+
+            await vueTicks();
+            await clickOnGroup('g2');
+            await clickOnGroup('g3');
+
+            assertOpenGroup('g3', ['abc']);
+        });
+
+        it('Test close group on second click', async function () {
+            store.state.scripts.scripts = [
+                {'name': 'abc', 'group': 'g3'},
+                {'name': 'def', 'group': 'g2'},
+                {'name': 'xyz', 'group': 'g2'}];
+
+            await vueTicks();
+            await clickOnGroup('g2');
+            await clickOnGroup('g2');
+
+            assertOpenGroup(null);
+        });
+
+    });
+});
\ No newline at end of file
diff --git a/web-src/tests/test_utils.js b/web-src/tests/test_utils.js
index d214f939..351b259e 100644
--- a/web-src/tests/test_utils.js
+++ b/web-src/tests/test_utils.js
@@ -77,12 +77,13 @@ export function setChipListValue(chipListComponent, value) {
     }
 }
 
-export function createVue(component, properties) {
+export function createVue(component, properties, store = null) {
     document.body.insertAdjacentHTML('afterbegin', '<div id="top-level-element"></div>');
     const topLevelElement = document.getElementById('top-level-element');
 
     const ComponentClass = Vue.extend(component);
     const vm = new ComponentClass({
+        store,
         propsData: properties
     }).$mount(topLevelElement);