diff --git a/cvat-ui/src/actions/tasks-actions.ts b/cvat-ui/src/actions/tasks-actions.ts
index 818aadedf6b7..6920034cf619 100644
--- a/cvat-ui/src/actions/tasks-actions.ts
+++ b/cvat-ui/src/actions/tasks-actions.ts
@@ -42,11 +42,11 @@ function getTasksSuccess(array: any[], previews: string[],
     return action;
 }
 
-function getTasksFailed(gettingTasksError: any, gettingQuery: TasksQuery): AnyAction {
+function getTasksFailed(tasksFetchingError: any, gettingQuery: TasksQuery): AnyAction {
     const action = {
         type: TasksActionTypes.GET_TASKS_FAILED,
         payload: {
-            gettingTasksError,
+            tasksFetchingError,
             gettingQuery,
         },
     };
@@ -70,8 +70,8 @@ ThunkAction<Promise<void>, {}, {}, AnyAction> {
         let result = null;
         try {
             result = await cvat.tasks.get(filteredQuery);
-        } catch (gettingTasksError) {
-            dispatch(getTasksFailed(gettingTasksError, gettingQuery));
+        } catch (tasksFetchingError) {
+            dispatch(getTasksFailed(tasksFetchingError, gettingQuery));
             return;
         }
 
diff --git a/cvat-ui/src/components/tasks-page/task-item.tsx b/cvat-ui/src/components/tasks-page/task-item.tsx
index bd13aa5cc880..d941393c1e88 100644
--- a/cvat-ui/src/components/tasks-page/task-item.tsx
+++ b/cvat-ui/src/components/tasks-page/task-item.tsx
@@ -16,18 +16,13 @@ import { ClickParam } from 'antd/lib/menu/index';
 import { UploadChangeParam } from 'antd/lib/upload';
 import { RcFile } from 'antd/lib/upload';
 
-import {
-    Task,
-    LoadState,
-    DumpState,
-} from '../../reducers/interfaces';
-
 import moment from 'moment';
 
 export interface TaskItemProps {
-    task: Task;
-    activeLoading: LoadState | null;
-    activeDumpings: DumpState[];
+    taskInstance: any;
+    previewImage: string;
+    dumpActivities: string[] | null;
+    loadActivity: string | null;
     loaders: any[];
     dumpers: any[];
     onDumpAnnotation: (task: any, dumper: any) => void;
@@ -45,7 +40,7 @@ export default class VisibleTaskItem extends React.PureComponent<TaskItemProps>
     }
 
     private handleMenuClick(params: ClickParam) {
-        const tracker = this.props.task.instance.bugTracker;
+        const tracker = this.props.taskInstance.bugTracker;
 
         if (params.keyPath.length === 2) {
             // dump or upload
@@ -77,12 +72,10 @@ export default class VisibleTaskItem extends React.PureComponent<TaskItemProps>
     }
 
     private renderPreview() {
-        const preview = this.props.task.preview;
-
         return (
             <Col span={4}>
                 <div className='cvat-task-preview-wrapper'>
-                    <img alt='Preview' className='cvat-task-preview' src={preview}/>
+                    <img alt='Preview' className='cvat-task-preview' src={this.props.previewImage}/>
                 </div>
             </Col>
         )
@@ -90,7 +83,7 @@ export default class VisibleTaskItem extends React.PureComponent<TaskItemProps>
 
     private renderDescription() {
     // Task info
-        const task = this.props.task.instance;
+        const task = this.props.taskInstance;
         const { id } = task;
         const owner = task.owner ? task.owner.username : null;
         const updated = moment(task.updatedDate).fromNow();
@@ -115,9 +108,10 @@ export default class VisibleTaskItem extends React.PureComponent<TaskItemProps>
     }
 
     private renderProgress() {
+        const task = this.props.taskInstance;
         // Count number of jobs and performed jobs
-        const numOfJobs = this.props.task.instance.jobs.length;
-        const numOfCompleted = this.props.task.instance.jobs.filter(
+        const numOfJobs = task.jobs.length;
+        const numOfCompleted = task.jobs.filter(
             (job: any) => job.status === 'completed'
         ).length;
 
@@ -158,17 +152,19 @@ export default class VisibleTaskItem extends React.PureComponent<TaskItemProps>
     }
 
     private renderDumperItem(dumper: any) {
-        const mode = this.props.task.instance.mode;
-        const dumpWithThisDumper = this.props.activeDumpings
-            .filter((dump: DumpState) => dump.dumperName === dumper.name)[0];
+        const task = this.props.taskInstance;
+        const { mode } = task;
+
+        const dumpingWithThisDumper = (this.props.dumpActivities || [])
+            .filter((_dumper: string) => _dumper === dumper.name)[0];
 
-        const pending = !!dumpWithThisDumper;
+        const pending = !!dumpingWithThisDumper;
 
         return (
             <Menu.Item className='cvat-task-item-dump-submenu-item' key={dumper.name}>
                 <Button block={true} type='link' disabled={pending}
                     onClick={() => {
-                        this.props.onDumpAnnotation(this.props.task.instance, dumper);
+                        this.props.onDumpAnnotation(task, dumper);
                     }}>
                     <Icon type='download'/>
                     <Text strong={isDefaultFormat(dumper.name, mode)}>
@@ -181,9 +177,9 @@ export default class VisibleTaskItem extends React.PureComponent<TaskItemProps>
     }
 
     private renderLoaderItem(loader: any) {
-        const loadingWithThisLoader = this.props.activeLoading
-            && this.props.activeLoading.loaderName === loader.name
-            ? this.props.activeLoading : null;
+        const loadingWithThisLoader = this.props.loadActivity
+            && this.props.loadActivity === loader.name
+            ? this.props.loadActivity : null;
 
         const pending = !!loadingWithThisLoader;
 
@@ -195,14 +191,14 @@ export default class VisibleTaskItem extends React.PureComponent<TaskItemProps>
                     showUploadList={ false }
                     beforeUpload={(file: RcFile) => {
                         this.props.onLoadAnnotation(
-                            this.props.task.instance,
+                            this.props.taskInstance,
                             loader,
                             file as File,
                         );
 
                         return false;
                 }}>
-                    <Button block={true} type='link' disabled={!!this.props.activeLoading}>
+                    <Button block={true} type='link' disabled={!!this.props.loadActivity}>
                         <Icon type='upload'/>
                         <Text> {loader.name} </Text>
                         {pending ? <Icon type='loading'/> : null}
@@ -213,7 +209,7 @@ export default class VisibleTaskItem extends React.PureComponent<TaskItemProps>
     }
 
     private renderMenu() {
-        const tracker = this.props.task.instance.bugTracker;
+        const tracker = this.props.taskInstance.bugTracker;
 
         return (
             <Menu subMenuCloseDelay={0.15} className='cvat-task-item-menu' onClick={this.handleMenuClick.bind(this)}>
diff --git a/cvat-ui/src/components/tasks-page/task-list.tsx b/cvat-ui/src/components/tasks-page/task-list.tsx
index fab290037285..04ad3534ad98 100644
--- a/cvat-ui/src/components/tasks-page/task-list.tsx
+++ b/cvat-ui/src/components/tasks-page/task-list.tsx
@@ -7,24 +7,19 @@ import {
 } from 'antd';
 
 import TaskItem from '../../containers/tasks-page/task-item';
-import { Task } from '../../reducers/interfaces';
 
 export interface ContentListProps {
-    onPageChange(page: number): void;
-    tasks: Task[];
-    page: number;
-    count: number;
+    onSwitchPage(page: number): void;
+    currentTasksIndexes: number[];
+    currentPage: number;
+    numberOfTasks: number;
 }
 
 export default function VisibleTaskList(props: ContentListProps) {
-    const taskViews = [];
-
-    for (let i = 0; i < props.tasks.length; i++) {
-        const task = props.tasks[i];
-        taskViews.push(
-            <TaskItem idx={i} taskID={task.instance.id} key={task.instance.id}/>
-        )
-    }
+    const tasks = props.currentTasksIndexes;
+    const taskViews = tasks.map(
+        (tid, id) => <TaskItem idx={id} taskID={tid} key={tid}/>
+    );
 
     return (
         <>
@@ -37,10 +32,10 @@ export default function VisibleTaskList(props: ContentListProps) {
                 <Col md={22} lg={18} xl={16} xxl={14}>
                     <Pagination
                         className='cvat-tasks-pagination'
-                        onChange={props.onPageChange}
-                        total={props.count}
+                        onChange={props.onSwitchPage}
+                        total={props.numberOfTasks}
                         pageSize={10}
-                        current={props.page}
+                        current={props.currentPage}
                         showQuickJumper
                     />
                 </Col>
diff --git a/cvat-ui/src/components/tasks-page/tasks-page.tsx b/cvat-ui/src/components/tasks-page/tasks-page.tsx
index c9b249d92930..d9b735f22581 100644
--- a/cvat-ui/src/components/tasks-page/tasks-page.tsx
+++ b/cvat-ui/src/components/tasks-page/tasks-page.tsx
@@ -16,15 +16,15 @@ import EmptyListComponent from './empty-list';
 import TaskListContainer from '../../containers/tasks-page/tasks-list';
 
 interface TasksPageProps {
-    dumpError: any;
-    loadError: any;
-    loadDone: string;
+    dumpingError: string;
+    loadingError: string;
+    tasksFetchingError: string;
+    loadingDoneMessage: string;
     tasksAreBeingFetched: boolean;
-    tasksFetchingError: any;
-    tasksQuery: TasksQuery;
+    gettingQuery: TasksQuery;
     numberOfTasks: number;
     numberOfVisibleTasks: number;
-    onGetTasks: (query: TasksQuery) => void;
+    onGetTasks: (gettingQuery: TasksQuery) => void;
 }
 
 class VisibleTasksPage extends React.PureComponent<TasksPageProps & RouteComponentProps> {
@@ -32,11 +32,11 @@ class VisibleTasksPage extends React.PureComponent<TasksPageProps & RouteCompone
         super(props);
     }
 
-    private updateURL(query: TasksQuery) {
+    private updateURL(gettingQuery: TasksQuery) {
         let queryString = '?';
-        for (const field of Object.keys(query)) {
-            if (query[field] !== null) {
-                queryString += `${field}=${query[field]}&`;
+        for (const field of Object.keys(gettingQuery)) {
+            if (gettingQuery[field] !== null) {
+                queryString += `${field}=${gettingQuery[field]}&`;
             }
         }
         this.props.history.replace({
@@ -44,17 +44,17 @@ class VisibleTasksPage extends React.PureComponent<TasksPageProps & RouteCompone
         });
     }
 
-    private getSearchField(query: TasksQuery): string {
+    private getSearchField(gettingQuery: TasksQuery): string {
         let searchString = '';
-        for (const field of Object.keys(query)) {
-            if (query[field] !== null && field !== 'page') {
+        for (const field of Object.keys(gettingQuery)) {
+            if (gettingQuery[field] !== null && field !== 'page') {
                 if (field === 'search') {
-                    return (query[field] as any) as string;
+                    return (gettingQuery[field] as any) as string;
                 } else {
-                    if (typeof (query[field] === 'number')) {
-                        searchString += `${field}:${query[field]} AND `;
+                    if (typeof (gettingQuery[field] === 'number')) {
+                        searchString += `${field}:${gettingQuery[field]} AND `;
                     } else {
-                        searchString += `${field}:"${query[field]}" AND `;
+                        searchString += `${field}:"${gettingQuery[field]}" AND `;
                     }
                 }
             }
@@ -64,14 +64,14 @@ class VisibleTasksPage extends React.PureComponent<TasksPageProps & RouteCompone
     }
 
     private handleSearch(value: string): void {
-        const query = { ...this.props.tasksQuery };
+        const gettingQuery = { ...this.props.gettingQuery };
         const search = value.replace(/\s+/g, ' ').replace(/\s*:+\s*/g, ':').trim();
 
         const fields = ['name', 'mode', 'owner', 'assignee', 'status', 'id'];
         for (const field of fields) {
-            query[field] = null;
+            gettingQuery[field] = null;
         }
-        query.search = null;
+        gettingQuery.search = null;
 
         let specificRequest = false;
         for (const param of search.split(/[\s]+and[\s]+|[\s]+AND[\s]+/)) {
@@ -81,53 +81,53 @@ class VisibleTasksPage extends React.PureComponent<TasksPageProps & RouteCompone
                     specificRequest = true;
                     if (name === 'id') {
                         if (Number.isInteger(+value)) {
-                            query[name] = +value;
+                            gettingQuery[name] = +value;
                         }
                     } else {
-                        query[name] = value;
+                        gettingQuery[name] = value;
                     }
                 }
             }
         }
 
-        query.page = 1;
+        gettingQuery.page = 1;
         if (!specificRequest && value) { // only id
-            query.search = value;
+            gettingQuery.search = value;
         }
 
-        this.updateURL(query);
-        this.props.onGetTasks(query);
+        this.updateURL(gettingQuery);
+        this.props.onGetTasks(gettingQuery);
     }
 
     private handlePagination(page: number): void {
-        const query = { ...this.props.tasksQuery };
+        const gettingQuery = { ...this.props.gettingQuery };
 
-        query.page = page;
-        this.updateURL(query);
-        this.props.onGetTasks(query);
+        gettingQuery.page = page;
+        this.updateURL(gettingQuery);
+        this.props.onGetTasks(gettingQuery);
     }
 
     public componentDidMount() {
-        const query = { ...this.props.tasksQuery };
+        const gettingQuery = { ...this.props.gettingQuery };
         const params = new URLSearchParams(this.props.location.search);
 
-        for (const field of Object.keys(query)) {
+        for (const field of Object.keys(gettingQuery)) {
             if (params.has(field)) {
                 const value = params.get(field);
                 if (value) {
                     if (field === 'id' || field === 'page') {
                         if (Number.isInteger(+value)) {
-                            query[field] = +value;
+                            gettingQuery[field] = +value;
                         }
                     } else {
-                        query[field] = value;
+                        gettingQuery[field] = value;
                     }
                 }
             }
         }
 
-        this.updateURL(query);
-        this.props.onGetTasks(query);
+        this.updateURL(gettingQuery);
+        this.props.onGetTasks(gettingQuery);
     }
 
     public componentDidUpdate() {
@@ -138,24 +138,24 @@ class VisibleTasksPage extends React.PureComponent<TasksPageProps & RouteCompone
             });
         }
 
-        if (this.props.dumpError) {
+        if (this.props.dumpingError) {
             Modal.error({
                 title: 'Could not dump annotations',
-                content: `${this.props.dumpError.toString()}`,
+                content: `${this.props.dumpingError}`,
             });;
         }
 
-        if (this.props.loadError) {
+        if (this.props.loadingError) {
             Modal.error({
                 title: 'Could not load annotations',
-                content: `${this.props.loadError.toString()}`,
+                content: `${this.props.loadingError}`,
             });;
         }
 
-        if (this.props.loadDone) {
+        if (this.props.loadingDoneMessage) {
             Modal.info({
-                title: 'Load annotations',
-                content: `${this.props.loadDone}`,
+                title: 'Successful loading of annotations',
+                content: `${this.props.loadingDoneMessage}`,
             });;
         }
     }
@@ -170,11 +170,11 @@ class VisibleTasksPage extends React.PureComponent<TasksPageProps & RouteCompone
                 <div className='tasks-page'>
                     <TopBar
                         onSearch={this.handleSearch.bind(this)}
-                        searchValue={this.getSearchField(this.props.tasksQuery)}
+                        searchValue={this.getSearchField(this.props.gettingQuery)}
                     />
                     {this.props.numberOfVisibleTasks ?
                         <TaskListContainer
-                            onPageChange={this.handlePagination.bind(this)}
+                            onSwitchPage={this.handlePagination.bind(this)}
                         /> : <EmptyListComponent/>}
                 </div>
             )
diff --git a/cvat-ui/src/containers/tasks-page/task-item.tsx b/cvat-ui/src/containers/tasks-page/task-item.tsx
index a6ed4c90a15e..b7f69ef5a490 100644
--- a/cvat-ui/src/containers/tasks-page/task-item.tsx
+++ b/cvat-ui/src/containers/tasks-page/task-item.tsx
@@ -3,7 +3,6 @@ import { connect } from 'react-redux';
 
 import {
     TasksQuery,
-    ActiveTask,
     Task,
 } from '../../reducers/interfaces';
 
@@ -18,8 +17,10 @@ import {
 } from '../../actions/tasks-actions';
 
 interface StateToProps {
-    task: Task;
-    activeTask: ActiveTask | undefined;
+    dumpActivities: string[] | null;
+    loadActivity: string | null;
+    previewImage: string;
+    taskInstance: any;
     loaders: any[];
     dumpers: any[];
 }
@@ -36,11 +37,18 @@ interface OwnProps {
 }
 
 function mapStateToProps(state: CombinedState, own: OwnProps): StateToProps {
+    const task = state.tasks.current[own.idx];
+    const { formats } = state;
+    const { dumps } = state.tasks.activities;
+    const { loads } = state.tasks.activities;
+
     return {
-        task: state.tasks.current[own.idx],
-        activeTask: state.tasks.active[own.taskID],
-        loaders: state.formats.loaders,
-        dumpers: state.formats.dumpers,
+        dumpActivities: dumps.byTask[own.taskID] ? dumps.byTask[own.taskID] : null,
+        loadActivity: loads.byTask[own.taskID] ? loads.byTask[own.taskID] : null,
+        previewImage: task.preview,
+        taskInstance: task.instance,
+        loaders: formats.loaders,
+        dumpers: formats.dumpers,
     };
 }
 
@@ -63,9 +71,10 @@ type TasksItemContainerProps = StateToProps & DispatchToProps & OwnProps;
 function TaskItemContainer(props: TasksItemContainerProps) {
     return (
         <TaskItemComponent
-            activeLoading={props.activeTask ? props.activeTask.load : null}
-            activeDumpings={props.activeTask ? [...props.activeTask.dump] : []}
-            task={props.task}
+            taskInstance={props.taskInstance}
+            previewImage={props.previewImage}
+            dumpActivities={props.dumpActivities}
+            loadActivity={props.loadActivity}
             loaders={props.loaders}
             dumpers={props.dumpers}
             onLoadAnnotation={props.load}
diff --git a/cvat-ui/src/containers/tasks-page/tasks-list.tsx b/cvat-ui/src/containers/tasks-page/tasks-list.tsx
index 5d737228b4b8..2ec04cdbad73 100644
--- a/cvat-ui/src/containers/tasks-page/tasks-list.tsx
+++ b/cvat-ui/src/containers/tasks-page/tasks-list.tsx
@@ -20,7 +20,7 @@ interface DispatchToProps {
 }
 
 interface OwnProps {
-    onPageChange: (page: number) => void;
+    onSwitchPage: (page: number) => void;
 }
 
 function mapStateToProps(state: CombinedState): StateToProps {
@@ -40,10 +40,10 @@ type TasksListContainerProps = StateToProps & DispatchToProps & OwnProps;
 function TasksListContainer(props: TasksListContainerProps) {
     return (
         <TasksListComponent
-            onPageChange={props.onPageChange}
-            tasks={props.tasks.current}
-            page={props.tasks.query.page}
-            count={props.tasks.count}
+            onSwitchPage={props.onSwitchPage}
+            currentTasksIndexes={props.tasks.current.map((task) => task.instance.id)}
+            currentPage={props.tasks.gettingQuery.page}
+            numberOfTasks={props.tasks.count}
         />
     );
 }
diff --git a/cvat-ui/src/containers/tasks-page/tasks-page.tsx b/cvat-ui/src/containers/tasks-page/tasks-page.tsx
index ea91c63de431..4e301dbc49c3 100644
--- a/cvat-ui/src/containers/tasks-page/tasks-page.tsx
+++ b/cvat-ui/src/containers/tasks-page/tasks-page.tsx
@@ -11,28 +11,33 @@ import TasksPageComponent from '../../components/tasks-page/tasks-page';
 import { getTasksAsync } from '../../actions/tasks-actions';
 
 interface StateToProps {
-    loadDone: string;
-    loadError: any;
-    dumpError: any;
-    tasksAreBeingFetched: boolean;
+    dumpingError: any;
+    loadingError: any;
     tasksFetchingError: any;
-    tasksQuery: TasksQuery;
+    loadingDoneMessage: string;
+    tasksAreBeingFetched: boolean;
+    gettingQuery: TasksQuery;
     numberOfTasks: number;
     numberOfVisibleTasks: number;
 }
 
 interface DispatchToProps {
-    getTasks: (query: TasksQuery) => void;
+    getTasks: (gettingQuery: TasksQuery) => void;
 }
 
 function mapStateToProps(state: CombinedState): StateToProps {
+    const { tasks } = state;
+    const { activities } = tasks;
+    const { dumps } = activities;
+    const { loads } = activities;
+
     return {
-        loadDone: state.tasks.loadDone,
-        loadError: state.tasks.loadError,
-        dumpError: state.tasks.dumpError,
+        dumpingError: dumps.dumpingError,
+        loadingError: loads.loadingError,
+        tasksFetchingError: tasks.tasksFetchingError,
+        loadingDoneMessage: loads.loadingDoneMessage,
         tasksAreBeingFetched: !state.tasks.initialized,
-        tasksFetchingError: state.tasks.error,
-        tasksQuery: state.tasks.query,
+        gettingQuery: tasks.gettingQuery,
         numberOfTasks: state.tasks.count,
         numberOfVisibleTasks: state.tasks.current.length,
     };
@@ -49,12 +54,12 @@ type TasksPageContainerProps = StateToProps & DispatchToProps;
 function TasksPageContainer(props: TasksPageContainerProps) {
     return (
         <TasksPageComponent
-            loadDone={props.loadDone}
-            loadError={props.loadError}
-            dumpError={props.dumpError}
+            dumpingError={props.dumpingError ? props.dumpingError.toString() : ''}
+            loadingError={props.loadingError ? props.loadingError.toString() : ''}
+            tasksFetchingError={props.tasksFetchingError ? props.tasksFetchingError.toString(): ''}
+            loadingDoneMessage={props.loadingDoneMessage}
             tasksAreBeingFetched={props.tasksAreBeingFetched}
-            tasksFetchingError={props.tasksFetchingError}
-            tasksQuery={props.tasksQuery}
+            gettingQuery={props.gettingQuery}
             numberOfTasks={props.numberOfTasks}
             numberOfVisibleTasks={props.numberOfVisibleTasks}
             onGetTasks={props.getTasks}
diff --git a/cvat-ui/src/reducers/interfaces.ts b/cvat-ui/src/reducers/interfaces.ts
index 056b8a306b94..b8818559160c 100644
--- a/cvat-ui/src/reducers/interfaces.ts
+++ b/cvat-ui/src/reducers/interfaces.ts
@@ -26,7 +26,7 @@ export interface Task {
 
 export interface TasksState {
     initialized: boolean;
-    gettingTasksError: any;
+    tasksFetchingError: any;
     gettingQuery: TasksQuery;
     count: number;
     current: Task[];
diff --git a/cvat-ui/src/reducers/tasks-reducer.ts b/cvat-ui/src/reducers/tasks-reducer.ts
index f12f30fd6afd..ba2d50096c3b 100644
--- a/cvat-ui/src/reducers/tasks-reducer.ts
+++ b/cvat-ui/src/reducers/tasks-reducer.ts
@@ -5,7 +5,7 @@ import { TasksState, Task } from './interfaces';
 
 const defaultState: TasksState = {
     initialized: false,
-    gettingTasksError: null,
+    tasksFetchingError: null,
     count: 0,
     current: [],
     gettingQuery: {
@@ -35,7 +35,7 @@ export default (inputState: TasksState = defaultState, action: AnyAction): Tasks
     function cleanupTemporaryInfo(stateToResetErrors: TasksState): TasksState {
         return {
             ...stateToResetErrors,
-            gettingTasksError: null,
+            tasksFetchingError: null,
             activities: {
                 ...stateToResetErrors.activities,
                 dumps: {
@@ -81,7 +81,7 @@ export default (inputState: TasksState = defaultState, action: AnyAction): Tasks
                 count: 0,
                 current: [],
                 gettingQuery: { ...action.payload.gettingQuery },
-                gettingTasksError: action.payload.gettingTasksError,
+                tasksFetchingError: action.payload.tasksFetchingError,
             };
         case TasksActionTypes.DUMP_ANNOTATIONS: {
             const { task } = action.payload;