diff --git a/changelog.d/20240426_143800_boris_manual_analytics_report.md b/changelog.d/20240426_143800_boris_manual_analytics_report.md
new file mode 100644
index 000000000000..e616757cca37
--- /dev/null
+++ b/changelog.d/20240426_143800_boris_manual_analytics_report.md
@@ -0,0 +1,4 @@
+### Changed
+
+- Analytics reports calculation may be initiated manually instead of automatic scheduling
+  (<https://github.com/cvat-ai/cvat/pull/7805>)
diff --git a/cvat-core/src/analytics-report.ts b/cvat-core/src/analytics-report.ts
index 4d3637c7ad67..895ecb128c2e 100644
--- a/cvat-core/src/analytics-report.ts
+++ b/cvat-core/src/analytics-report.ts
@@ -1,9 +1,10 @@
-// Copyright (C) 2023 CVAT.ai Corporation
+// Copyright (C) 2023-2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
 import {
-    SerializedAnalyticsEntry, SerializedAnalyticsReport, SerializedDataEntry, SerializedTransformationEntry,
+    SerializedAnalyticsEntry, SerializedAnalyticsReport,
+    SerializedDataEntry, SerializedTransformationEntry,
 } from './server-response-types';
 import { ArgumentError } from './exceptions';
 
@@ -126,7 +127,7 @@ export default class AnalyticsReport {
     #statistics: AnalyticsEntry[];
 
     constructor(initialData: SerializedAnalyticsReport) {
-        this.#id = initialData.id;
+        this.#id = initialData.job_id || initialData.task_id || initialData.project_id;
         this.#target = initialData.target as AnalyticsReportTarget;
         this.#createdDate = initialData.created_date;
         this.#statistics = [];
diff --git a/cvat-core/src/api-implementation.ts b/cvat-core/src/api-implementation.ts
index 331ea9e5d8da..b9d3d1f450d5 100644
--- a/cvat-core/src/api-implementation.ts
+++ b/cvat-core/src/api-implementation.ts
@@ -29,7 +29,10 @@ import CloudStorage from './cloud-storage';
 import Organization, { Invitation } from './organization';
 import Webhook from './webhook';
 import { ArgumentError } from './exceptions';
-import { SerializedAsset } from './server-response-types';
+import {
+    AnalyticsReportFilter, QualityConflictsFilter, QualityReportsFilter,
+    QualitySettingsFilter, SerializedAsset,
+} from './server-response-types';
 import QualityReport from './quality-report';
 import QualityConflict, { ConflictSeverity } from './quality-conflict';
 import QualitySettings from './quality-settings';
@@ -403,7 +406,7 @@ export default function implementAPI(cvat: CVATCore): CVATCore {
         return webhooks;
     });
 
-    implementationMixin(cvat.analytics.quality.reports, async (filter) => {
+    implementationMixin(cvat.analytics.quality.reports, async (filter: QualityReportsFilter) => {
         checkFilter(filter, {
             page: isInteger,
             pageSize: isPageSize,
@@ -426,7 +429,7 @@ export default function implementAPI(cvat: CVATCore): CVATCore {
         );
         return reports;
     });
-    implementationMixin(cvat.analytics.quality.conflicts, async (filter) => {
+    implementationMixin(cvat.analytics.quality.conflicts, async (filter: QualityConflictsFilter) => {
         checkFilter(filter, {
             reportID: isInteger,
         });
@@ -502,7 +505,7 @@ export default function implementAPI(cvat: CVATCore): CVATCore {
 
         return mergedConflicts;
     });
-    implementationMixin(cvat.analytics.quality.settings.get, async (filter) => {
+    implementationMixin(cvat.analytics.quality.settings.get, async (filter: QualitySettingsFilter) => {
         checkFilter(filter, {
             taskID: isInteger,
         });
@@ -512,7 +515,7 @@ export default function implementAPI(cvat: CVATCore): CVATCore {
         const settings = await serverProxy.analytics.quality.settings.get(params);
         return new QualitySettings({ ...settings });
     });
-    implementationMixin(cvat.analytics.performance.reports, async (filter) => {
+    implementationMixin(cvat.analytics.performance.reports, async (filter: AnalyticsReportFilter) => {
         checkFilter(filter, {
             jobID: isInteger,
             taskID: isInteger,
@@ -527,9 +530,30 @@ export default function implementAPI(cvat: CVATCore): CVATCore {
         const reportData = await serverProxy.analytics.performance.reports(params);
         return new AnalyticsReport(reportData);
     });
+    implementationMixin(cvat.analytics.performance.calculate, async (
+        body: Parameters<CVATCore['analytics']['performance']['calculate']>[0],
+        onUpdate: Parameters<CVATCore['analytics']['performance']['calculate']>[1],
+    ) => {
+        checkFilter(body, {
+            jobID: isInteger,
+            taskID: isInteger,
+            projectID: isInteger,
+        });
+
+        checkExclusiveFields(body, ['jobID', 'taskID', 'projectID'], []);
+        if (!('jobID' in body || 'taskID' in body || 'projectID' in body)) {
+            throw new ArgumentError('One of "jobID", "taskID", "projectID" is required, but not provided');
+        }
+
+        const params = fieldsToSnakeCase(body);
+        await serverProxy.analytics.performance.calculate(params, onUpdate);
+    });
     implementationMixin(cvat.frames.getMeta, async (type, id) => {
         const result = await serverProxy.frames.getMeta(type, id);
-        return new FramesMetaData({ ...result });
+        return new FramesMetaData({
+            ...result,
+            deleted_frames: Object.fromEntries(result.deleted_frames.map((_frame) => [_frame, true])),
+        });
     });
 
     return cvat;
diff --git a/cvat-core/src/api.ts b/cvat-core/src/api.ts
index d4c6a21e9bf2..20e9ce8577fa 100644
--- a/cvat-core/src/api.ts
+++ b/cvat-core/src/api.ts
@@ -348,6 +348,14 @@ function build(): CVATCore {
                     const result = await PluginRegistry.apiWrapper(cvat.analytics.performance.reports, filter);
                     return result;
                 },
+                async calculate(body, onUpdate) {
+                    const result = await PluginRegistry.apiWrapper(
+                        cvat.analytics.performance.calculate,
+                        body,
+                        onUpdate,
+                    );
+                    return result;
+                },
             },
             quality: {
                 async reports(filter = {}) {
diff --git a/cvat-core/src/index.ts b/cvat-core/src/index.ts
index 9db3b5fca9e1..402ea4a69d9b 100644
--- a/cvat-core/src/index.ts
+++ b/cvat-core/src/index.ts
@@ -105,11 +105,11 @@ export default interface CVATCore {
     projects: {
         get: (
             filter: {
-                id: number;
-                page: number;
-                search: string;
-                sort: string;
-                filter: string;
+                id?: number;
+                page?: number;
+                search?: string;
+                sort?: string;
+                filter?: string;
             }
         ) => Promise<PaginatedResource<Project>>;
         searchNames: any;
@@ -141,6 +141,10 @@ export default interface CVATCore {
         };
         performance: {
             reports: (filter: AnalyticsReportFilter) => Promise<AnalyticsReport>;
+            calculate: (
+                body: { jobID?: number; taskID?: number; projectID?: number; },
+                onUpdate: (status: enums.RQStatus, progress: number, message: string) => void,
+            ) => Promise<void>;
         };
     };
     frames: {
diff --git a/cvat-core/src/server-proxy.ts b/cvat-core/src/server-proxy.ts
index 6d9e9f118021..228f467490f6 100644
--- a/cvat-core/src/server-proxy.ts
+++ b/cvat-core/src/server-proxy.ts
@@ -1,5 +1,5 @@
 // Copyright (C) 2019-2022 Intel Corporation
-// Copyright (C) 2022-2023 CVAT.ai Corporation
+// Copyright (C) 2022-2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -16,8 +16,8 @@ import {
     SerializedAbout, SerializedRemoteFile, SerializedUserAgreement,
     SerializedRegister, JobsFilter, SerializedJob, SerializedGuide, SerializedAsset, SerializedAPISchema,
     SerializedInvitationData, SerializedCloudStorage, SerializedFramesMetaData, SerializedCollection,
-    SerializedQualitySettingsData, ApiQualitySettingsFilter, SerializedQualityConflictData, ApiQualityConflictsFilter,
-    SerializedQualityReportData, ApiQualityReportsFilter, SerializedAnalyticsReport, ApiAnalyticsReportFilter,
+    SerializedQualitySettingsData, APIQualitySettingsFilter, SerializedQualityConflictData, APIQualityConflictsFilter,
+    SerializedQualityReportData, APIQualityReportsFilter, SerializedAnalyticsReport, APIAnalyticsReportFilter,
 } from './server-response-types';
 import { PaginatedResource } from './core-types';
 import { Storage } from './storage';
@@ -1172,18 +1172,20 @@ async function restoreProject(storage: Storage, file: File | string) {
     return wait();
 }
 
-const listenToCreateCallbacks: Record<number, {
-    promise: Promise<SerializedTask>;
+type LongProcessListener<R> = Record<number, {
+    promise: Promise<R>;
     onUpdate: ((state: string, progress: number, message: string) => void)[];
-}> = {};
+}>;
+
+const listenToCreateTaskCallbacks: LongProcessListener<SerializedTask> = {};
 
 function listenToCreateTask(
     id, onUpdate: (state: RQStatus, progress: number, message: string) => void,
 ): Promise<SerializedTask> {
-    if (id in listenToCreateCallbacks) {
-        listenToCreateCallbacks[id].onUpdate.push(onUpdate);
+    if (id in listenToCreateTaskCallbacks) {
+        listenToCreateTaskCallbacks[id].onUpdate.push(onUpdate);
         // to avoid extra status check requests we do not create any more promises
-        return listenToCreateCallbacks[id].promise;
+        return listenToCreateTaskCallbacks[id].promise;
     }
 
     const promise = new Promise<SerializedTask>((resolve, reject) => {
@@ -1195,7 +1197,7 @@ function listenToCreateTask(
                 const state = response.data.state?.toLowerCase();
                 if ([RQStatus.QUEUED, RQStatus.STARTED].includes(state)) {
                     // notify all the subscribtions when data status changed
-                    listenToCreateCallbacks[id].onUpdate.forEach((callback) => {
+                    listenToCreateTaskCallbacks[id].onUpdate.forEach((callback) => {
                         callback(
                             state,
                             response.data.progress || 0,
@@ -1210,14 +1212,14 @@ function listenToCreateTask(
                     resolve(createdTask);
                 } else if (state === RQStatus.FAILED) {
                     const failMessage = 'Images processing failed';
-                    listenToCreateCallbacks[id].onUpdate.forEach((callback) => {
+                    listenToCreateTaskCallbacks[id].onUpdate.forEach((callback) => {
                         callback(state, 0, failMessage);
                     });
 
                     reject(new ServerError(filterPythonTraceback(response.data.message), 400));
                 } else {
                     const failMessage = 'Unknown status received';
-                    listenToCreateCallbacks[id].onUpdate.forEach((callback) => {
+                    listenToCreateTaskCallbacks[id].onUpdate.forEach((callback) => {
                         callback(state || RQStatus.UNKNOWN, 0, failMessage);
                     });
                     reject(
@@ -1228,7 +1230,7 @@ function listenToCreateTask(
                     );
                 }
             } catch (errorData) {
-                listenToCreateCallbacks[id].onUpdate.forEach((callback) => {
+                listenToCreateTaskCallbacks[id].onUpdate.forEach((callback) => {
                     callback('failed', 0, 'Server request failed');
                 });
                 reject(generateError(errorData));
@@ -1238,13 +1240,13 @@ function listenToCreateTask(
         setTimeout(checkStatus, 100);
     });
 
-    listenToCreateCallbacks[id] = {
+    listenToCreateTaskCallbacks[id] = {
         promise,
         onUpdate: [onUpdate],
     };
     promise.catch(() => {
         // do nothing, avoid uncaught promise exceptions
-    }).finally(() => delete listenToCreateCallbacks[id]);
+    }).finally(() => delete listenToCreateTaskCallbacks[id]);
     return promise;
 }
 
@@ -2324,7 +2326,7 @@ async function createAsset(file: File, guideId: number): Promise<SerializedAsset
 }
 
 async function getQualitySettings(
-    filter: ApiQualitySettingsFilter,
+    filter: APIQualitySettingsFilter,
 ): Promise<SerializedQualitySettingsData> {
     const { backendAPI } = config;
 
@@ -2360,7 +2362,7 @@ async function updateQualitySettings(
 }
 
 async function getQualityConflicts(
-    filter: ApiQualityConflictsFilter,
+    filter: APIQualityConflictsFilter,
 ): Promise<SerializedQualityConflictData[]> {
     const params = enableOrganization();
     const { backendAPI } = config;
@@ -2378,7 +2380,7 @@ async function getQualityConflicts(
 }
 
 async function getQualityReports(
-    filter: ApiQualityReportsFilter,
+    filter: APIQualityReportsFilter,
 ): Promise<PaginatedResource<SerializedQualityReportData>> {
     const { backendAPI } = config;
 
@@ -2397,7 +2399,7 @@ async function getQualityReports(
 }
 
 async function getAnalyticsReports(
-    filter: ApiAnalyticsReportFilter,
+    filter: APIAnalyticsReportFilter,
 ): Promise<SerializedAnalyticsReport> {
     const { backendAPI } = config;
 
@@ -2414,6 +2416,86 @@ async function getAnalyticsReports(
     }
 }
 
+const listenToCreateAnalyticsReportCallbacks: {
+    job: LongProcessListener<void>;
+    task: LongProcessListener<void>;
+    project: LongProcessListener<void>;
+} = {
+    job: {},
+    task: {},
+    project: {},
+};
+
+async function calculateAnalyticsReport(
+    body: {
+        job_id?: number;
+        task_id?: number;
+        project_id?: number;
+    },
+    onUpdate: (state: string, progress: number, message: string) => void,
+): Promise<void> {
+    const id = body.job_id || body.task_id || body.project_id;
+    const { backendAPI } = config;
+    const params = enableOrganization();
+    let listenerStorage: LongProcessListener<void> = null;
+
+    if (Number.isInteger(body.job_id)) {
+        listenerStorage = listenToCreateAnalyticsReportCallbacks.job;
+    } else if (Number.isInteger(body.task_id)) {
+        listenerStorage = listenToCreateAnalyticsReportCallbacks.task;
+    } else if (Number.isInteger(body.project_id)) {
+        listenerStorage = listenToCreateAnalyticsReportCallbacks.project;
+    }
+
+    if (listenerStorage[id]) {
+        listenerStorage[id].onUpdate.push(onUpdate);
+        return listenerStorage[id].promise;
+    }
+
+    const promise = new Promise<void>((resolve, reject) => {
+        Axios.post(`${backendAPI}/analytics/reports`, {
+            ...body,
+            ...params,
+        }).then(({ data: { rq_id: rqID } }) => {
+            listenerStorage[id].onUpdate.forEach((_onUpdate) => _onUpdate(RQStatus.QUEUED, 0, 'Analytics report request sent'));
+            const checkStatus = (): void => {
+                Axios.post(`${backendAPI}/analytics/reports`, {
+                    ...body,
+                    ...params,
+                }, { params: { rq_id: rqID } }).then((response) => {
+                    // TODO: rewrite server logic, now it returns 202, 201 codes, but we need RQ statuses and details
+                    // after this patch is merged https://github.com/cvat-ai/cvat/pull/7537
+                    if (response.status === 201) {
+                        listenerStorage[id].onUpdate.forEach((_onUpdate) => _onUpdate(RQStatus.FINISHED, 0, 'Done'));
+                        resolve();
+                        return;
+                    }
+
+                    listenerStorage[id].onUpdate.forEach((_onUpdate) => _onUpdate(RQStatus.QUEUED, 0, 'Analytics report calculation is in progress'));
+                    setTimeout(checkStatus, 10000);
+                }).catch((errorData) => {
+                    reject(generateError(errorData));
+                });
+            };
+
+            setTimeout(checkStatus, 2500);
+        }).catch((errorData) => {
+            reject(generateError(errorData));
+        });
+    });
+
+    listenerStorage[id] = {
+        promise,
+        onUpdate: [onUpdate],
+    };
+
+    promise.finally(() => {
+        delete listenerStorage[id];
+    });
+
+    return promise;
+}
+
 export default Object.freeze({
     server: Object.freeze({
         setAuthData,
@@ -2565,6 +2647,7 @@ export default Object.freeze({
     analytics: Object.freeze({
         performance: Object.freeze({
             reports: getAnalyticsReports,
+            calculate: calculateAnalyticsReport,
         }),
         quality: Object.freeze({
             reports: getQualityReports,
diff --git a/cvat-core/src/server-response-types.ts b/cvat-core/src/server-response-types.ts
index 1894b17078f5..0bcce7cfb67e 100644
--- a/cvat-core/src/server-response-types.ts
+++ b/cvat-core/src/server-response-types.ts
@@ -26,7 +26,7 @@ export interface SerializedAnnotationFormats {
     exporters: SerializedAnnotationExporter[];
 }
 
-export interface ApiCommonFilterParams {
+export interface APICommonFilterParams {
     page?: number;
     page_size?: number | 'all';
     filter?: string;
@@ -36,7 +36,7 @@ export interface ApiCommonFilterParams {
     search?: string;
 }
 
-export interface ProjectsFilter extends ApiCommonFilterParams {
+export interface ProjectsFilter extends APICommonFilterParams {
     id?: number;
 }
 
@@ -233,10 +233,10 @@ export interface SerializedOrganization {
     contact?: SerializedOrganizationContact,
 }
 
-export interface ApiQualitySettingsFilter extends ApiCommonFilterParams {
+export interface APIQualitySettingsFilter extends APICommonFilterParams {
     task_id?: number;
 }
-export type QualitySettingsFilter = Camelized<ApiQualitySettingsFilter>;
+export type QualitySettingsFilter = Camelized<APIQualitySettingsFilter>;
 
 export interface SerializedQualitySettingsData {
     id?: number;
@@ -255,10 +255,10 @@ export interface SerializedQualitySettingsData {
     compare_attributes?: boolean;
 }
 
-export interface ApiQualityConflictsFilter extends ApiCommonFilterParams {
+export interface APIQualityConflictsFilter extends APICommonFilterParams {
     report_id?: number;
 }
-export type QualityConflictsFilter = Camelized<ApiQualityConflictsFilter>;
+export type QualityConflictsFilter = Camelized<APIQualityConflictsFilter>;
 
 export interface SerializedAnnotationConflictData {
     job_id?: number;
@@ -279,14 +279,14 @@ export interface SerializedQualityConflictData {
     description?: string;
 }
 
-export interface ApiQualityReportsFilter extends ApiCommonFilterParams {
+export interface APIQualityReportsFilter extends APICommonFilterParams {
     parent_id?: number;
     peoject_id?: number;
     task_id?: number;
     job_id?: number;
     target?: string;
 }
-export type QualityReportsFilter = Camelized<ApiQualityReportsFilter>;
+export type QualityReportsFilter = Camelized<APIQualityReportsFilter>;
 
 export interface SerializedQualityReportData {
     id?: number;
@@ -345,17 +345,19 @@ export interface SerializedAnalyticsEntry {
     transformations?: SerializedTransformationEntry[];
 }
 
-export interface ApiAnalyticsReportFilter extends ApiCommonFilterParams {
+export interface APIAnalyticsReportFilter {
     project_id?: number;
     task_id?: number;
     job_id?: number;
     start_date?: string;
     end_date?: string;
 }
-export type AnalyticsReportFilter = Camelized<ApiAnalyticsReportFilter>;
+export type AnalyticsReportFilter = Camelized<APIAnalyticsReportFilter>;
 
 export interface SerializedAnalyticsReport {
-    id?: number;
+    job_id?: number;
+    task_id?: number;
+    project_id?: number;
     target?: string;
     created_date?: string;
     statistics?: SerializedAnalyticsEntry[];
diff --git a/cvat-ui/src/components/analytics-page/analytics-page.tsx b/cvat-ui/src/components/analytics-page/analytics-page.tsx
index 8284130052f9..410fd3007f0b 100644
--- a/cvat-ui/src/components/analytics-page/analytics-page.tsx
+++ b/cvat-ui/src/components/analytics-page/analytics-page.tsx
@@ -13,7 +13,9 @@ import Title from 'antd/lib/typography/Title';
 import notification from 'antd/lib/notification';
 import { useIsMounted } from 'utils/hooks';
 import { Project, Task } from 'reducers';
-import { AnalyticsReport, Job, getCore } from 'cvat-core-wrapper';
+import {
+    AnalyticsReport, Job, RQStatus, getCore,
+} from 'cvat-core-wrapper';
 import moment from 'moment';
 import CVATLoadingSpinner from 'components/common/loading-spinner';
 import GoBackButton from 'components/common/go-back-button';
@@ -53,106 +55,121 @@ function handleTimePeriod(interval: DateIntervals): [string, string] {
     }
 }
 
+function readInstanceType(location: ReturnType<typeof useLocation>): InstanceType {
+    if (location.pathname.includes('projects')) {
+        return 'project';
+    }
+    if (location.pathname.includes('jobs')) {
+        return 'job';
+    }
+    return 'task';
+}
+
+function readInstanceId(type: InstanceType): number {
+    if (type === 'project') {
+        return +useParams<{ pid: string }>().pid;
+    }
+    if (type === 'job') {
+        return +useParams<{ jid: string }>().jid;
+    }
+    return +useParams<{ tid: string }>().tid;
+}
+
 type InstanceType = 'project' | 'task' | 'job';
 
 function AnalyticsPage(): JSX.Element {
     const location = useLocation();
 
-    const requestedInstanceType: InstanceType = (() => {
-        if (location.pathname.includes('projects')) {
-            return 'project';
-        }
-        if (location.pathname.includes('jobs')) {
-            return 'job';
-        }
-        return 'task';
-    })();
-
-    const requestedInstanceID: number = (() => {
-        if (requestedInstanceType === 'project') {
-            return +useParams<{ pid: string }>().pid;
-        }
-        if (requestedInstanceType === 'job') {
-            return +useParams<{ jid: string }>().jid;
-        }
-        return +useParams<{ tid: string }>().tid;
-    })();
+    const requestedInstanceType: InstanceType = readInstanceType(location);
+    const requestedInstanceID = readInstanceId(requestedInstanceType);
 
     const [activeTab, setTab] = useState(getTabFromHash());
-
     const [instanceType, setInstanceType] = useState<InstanceType | null>(null);
     const [instance, setInstance] = useState<Project | Task | Job | null>(null);
     const [analyticsReport, setAnalyticsReport] = useState<AnalyticsReport | null>(null);
     const [timePeriod, setTimePeriod] = useState<DateIntervals>(DateIntervals.LAST_WEEK);
+    const [reportRefreshingStatus, setReportRefreshingStatus] = useState<string | null>(null);
     const [fetching, setFetching] = useState(true);
     const isMounted = useIsMounted();
 
-    const receiveInstance = (type: InstanceType, id: number): Promise<Task[] | Job[] | Project[]> => {
-        if (type === 'project') {
-            return core.projects.get({ id });
-        }
+    const receiveInstance = async (type: InstanceType, id: number): Promise<void> => {
+        let receivedInstance: Task | Project | Job | null = null;
 
-        if (type === 'task') {
-            return core.tasks.get({ id });
-        }
+        try {
+            switch (type) {
+                case 'project': {
+                    [receivedInstance] = await core.projects.get({ id });
+                    break;
+                }
+                case 'task': {
+                    [receivedInstance] = await core.tasks.get({ id });
+                    break;
+                }
+                case 'job': {
+                    [receivedInstance] = await core.jobs.get({ jobID: id });
+                    break;
+                }
+                default:
+                    return;
+            }
 
-        return core.jobs.get({ jobID: id });
+            if (isMounted()) {
+                setInstance(receivedInstance);
+                setInstanceType(type);
+            }
+        } catch (error: unknown) {
+            notification.error({
+                message: `Could not receive requested ${type}`,
+                description: `${error instanceof Error ? error.message : ''}`,
+            });
+        }
     };
 
-    const receiveReport = (timeInterval: DateIntervals, type: InstanceType, id: number): Promise<AnalyticsReport> => {
+    const receiveReport = async (timeInterval: DateIntervals, type: InstanceType, id: number): Promise<void> => {
         const [endDate, startDate] = handleTimePeriod(timeInterval);
-        if (type === 'project') {
-            return core.analytics.performance.reports({
-                projectID: id,
-                endDate,
-                startDate,
-            });
-        }
+        let report: AnalyticsReport | null = null;
+
+        try {
+            const body = { endDate, startDate };
+            switch (type) {
+                case 'project': {
+                    report = await core.analytics.performance.reports({ ...body, projectID: id });
+                    break;
+                }
+                case 'task': {
+                    report = await core.analytics.performance.reports({ ...body, taskID: id });
+                    break;
+                }
+                case 'job': {
+                    report = await core.analytics.performance.reports({ ...body, jobID: id });
+                    break;
+                }
+                default:
+                    return;
+            }
 
-        if (type === 'task') {
-            return core.analytics.performance.reports({
-                taskID: id,
-                endDate,
-                startDate,
+            if (isMounted()) {
+                setAnalyticsReport(report);
+            }
+        } catch (error: unknown) {
+            notification.error({
+                message: 'Could not receive requested report',
+                description: `${error instanceof Error ? error.message : ''}`,
             });
         }
-
-        return core.analytics.performance.reports({
-            jobID: id,
-            endDate,
-            startDate,
-        });
     };
 
     useEffect(() => {
-        setFetching(true);
-
         if (Number.isInteger(requestedInstanceID) && ['project', 'task', 'job'].includes(requestedInstanceType)) {
+            setFetching(true);
             Promise.all([
                 receiveInstance(requestedInstanceType, requestedInstanceID),
                 receiveReport(timePeriod, requestedInstanceType, requestedInstanceID),
-            ])
-                .then(([instanceResponse, report]) => {
-                    const receivedInstance: Task | Project | Job = instanceResponse[0];
-                    if (receivedInstance && isMounted()) {
-                        setInstance(receivedInstance);
-                        setInstanceType(requestedInstanceType);
-                    }
-                    if (report && isMounted()) {
-                        setAnalyticsReport(report);
-                    }
-                })
-                .catch((error: Error) => {
-                    notification.error({
-                        message: 'Could not receive requested resources',
-                        description: `${error.toString()}`,
-                    });
-                })
-                .finally(() => {
-                    if (isMounted()) {
-                        setFetching(false);
-                    }
-                });
+            ]).finally(() => {
+                if (isMounted()) {
+                    setFetching(false);
+                }
+            });
         } else {
             notification.error({
                 message: 'Could not load this page',
@@ -168,6 +185,42 @@ function AnalyticsPage(): JSX.Element {
         };
     }, [requestedInstanceType, requestedInstanceID, timePeriod]);
 
+    useEffect(() => {
+        window.addEventListener('hashchange', () => {
+            const hash = getTabFromHash();
+            setTab(hash);
+        });
+    }, []);
+
+    useEffect(() => {
+        window.location.hash = activeTab;
+    }, [activeTab]);
+
+    const onCreateReport = useCallback(() => {
+        const onUpdate = (status: RQStatus, progress: number, message: string): void => {
+            setReportRefreshingStatus(message);
+        };
+
+        const body = {
+            ...(requestedInstanceType === 'project' ? { projectID: requestedInstanceID } : {}),
+            ...(requestedInstanceType === 'task' ? { taskID: requestedInstanceID } : {}),
+            ...(requestedInstanceType === 'job' ? { jobID: requestedInstanceID } : {}),
+        };
+
+        core.analytics.performance.calculate(body, onUpdate).then(() => {
+            receiveReport(timePeriod, requestedInstanceType, requestedInstanceID);
+        }).finally(() => {
+            setReportRefreshingStatus(null);
+        }).catch((error: unknown) => {
+            if (isMounted()) {
+                notification.error({
+                    message: 'Error occurred during requesting performance report',
+                    description: error instanceof Error ? error.message : '',
+                });
+            }
+        });
+    }, [requestedInstanceType, requestedInstanceID, timePeriod]);
+
     const onJobUpdate = useCallback((job: Job): void => {
         setFetching(true);
 
@@ -185,20 +238,9 @@ function AnalyticsPage(): JSX.Element {
             });
     }, []);
 
-    useEffect(() => {
-        window.addEventListener('hashchange', () => {
-            const hash = getTabFromHash();
-            setTab(hash);
-        });
-    }, []);
-
-    const onTabKeyChange = (key: string): void => {
+    const onTabKeyChange = useCallback((key: string): void => {
         setTab(key as AnalyticsTabs);
-    };
-
-    useEffect(() => {
-        window.location.hash = activeTab;
-    }, [activeTab]);
+    }, []);
 
     let backNavigation: JSX.Element | null = null;
     let title: JSX.Element | null = null;
@@ -238,7 +280,9 @@ function AnalyticsPage(): JSX.Element {
                     <AnalyticsOverview
                         report={analyticsReport}
                         timePeriod={timePeriod}
+                        reportRefreshingStatus={reportRefreshingStatus}
                         onTimePeriodChange={setTimePeriod}
+                        onCreateReport={onCreateReport}
                     />
                 </Tabs.TabPane>
                 {instanceType === 'task' && (
diff --git a/cvat-ui/src/components/analytics-page/analytics-performance.tsx b/cvat-ui/src/components/analytics-page/analytics-performance.tsx
index 164504f7816c..afeab8ccbfd4 100644
--- a/cvat-ui/src/components/analytics-page/analytics-performance.tsx
+++ b/cvat-ui/src/components/analytics-page/analytics-performance.tsx
@@ -8,8 +8,14 @@ import RGL, { WidthProvider } from 'react-grid-layout';
 import Text from 'antd/lib/typography/Text';
 import Select from 'antd/lib/select';
 import Notification from 'antd/lib/notification';
-import { AnalyticsReport, AnalyticsEntryViewType } from 'cvat-core-wrapper';
 import { Col, Row } from 'antd/lib/grid';
+import Button from 'antd/lib/button';
+import Card from 'antd/lib/card';
+import Title from 'antd/lib/typography/Title';
+import { ReloadOutlined, LoadingOutlined } from '@ant-design/icons';
+
+import { AnalyticsReport, AnalyticsEntryViewType } from 'cvat-core-wrapper';
+import CVATTooltip from 'components/common/cvat-tooltip';
 import HistogramView from './views/histogram-view';
 import AnalyticsCard from './views/analytics-card';
 
@@ -25,7 +31,9 @@ export enum DateIntervals {
 interface Props {
     report: AnalyticsReport | null;
     timePeriod: DateIntervals;
+    reportRefreshingStatus: string | null;
     onTimePeriodChange: (val: DateIntervals) => void;
+    onCreateReport: () => void;
 }
 
 const colors = [
@@ -37,12 +45,44 @@ const colors = [
 ];
 
 function AnalyticsOverview(props: Props): JSX.Element | null {
-    const { report, timePeriod, onTimePeriodChange } = props;
+    const {
+        report, timePeriod, reportRefreshingStatus,
+        onTimePeriodChange, onCreateReport,
+    } = props;
 
-    if (!report) return null;
     const layout: any = [];
     let histogramCount = 0;
     let numericCount = 0;
+
+    if (report === null) {
+        return null;
+    }
+
+    if (!report.id) {
+        return (
+            <div className='cvat-analytics-overview'>
+                <Row>
+                    <Col span={24}>
+                        <Card>
+                            <div className='cvat-empty-performance-analytics-item'>
+                                {reportRefreshingStatus ? <Text>{reportRefreshingStatus}</Text> :
+                                    <Title level={5}> Performance report was not calculated yet... </Title>}
+                                <Button
+                                    onClick={onCreateReport}
+                                    loading={reportRefreshingStatus !== null}
+                                    disabled={reportRefreshingStatus !== null}
+                                    type='primary'
+                                >
+                                    Request
+                                </Button>
+                            </div>
+                        </Card>
+                    </Col>
+                </Row>
+            </div>
+        );
+    }
+
     const views: { view: React.JSX.Element, key: string }[] = [];
     report.statistics.forEach((entry) => {
         const tooltip = (
@@ -138,12 +178,21 @@ function AnalyticsOverview(props: Props): JSX.Element | null {
             }
         }
     });
+
     return (
         <div className='cvat-analytics-overview'>
             <Row justify='space-between'>
                 <Col>
+                    <CVATTooltip title='Request calculating a new report'>
+                        <Button
+                            className='cvat-analytics-refresh-button'
+                            onClick={onCreateReport}
+                            icon={reportRefreshingStatus !== null ? <LoadingOutlined /> : <ReloadOutlined />}
+                            disabled={reportRefreshingStatus !== null}
+                        />
+                    </CVATTooltip>
                     <Text type='secondary'>
-                        {`Created ${report?.createdDate ? moment(report?.createdDate).fromNow() : ''}`}
+                        { reportRefreshingStatus || `Created ${report?.id ? moment(report.createdDate).fromNow() : ''}`}
                     </Text>
                 </Col>
                 <Col>
@@ -151,24 +200,19 @@ function AnalyticsOverview(props: Props): JSX.Element | null {
                         placeholder='Select time period'
                         value={timePeriod}
                         onChange={onTimePeriodChange}
-                        options={[
-                            {
-                                value: DateIntervals.LAST_WEEK,
-                                label: DateIntervals.LAST_WEEK,
-                            },
-                            {
-                                value: DateIntervals.LAST_MONTH,
-                                label: DateIntervals.LAST_MONTH,
-                            },
-                            {
-                                value: DateIntervals.LAST_QUARTER,
-                                label: DateIntervals.LAST_QUARTER,
-                            },
-                            {
-                                value: DateIntervals.LAST_YEAR,
-                                label: DateIntervals.LAST_YEAR,
-                            },
-                        ]}
+                        options={[{
+                            value: DateIntervals.LAST_WEEK,
+                            label: DateIntervals.LAST_WEEK,
+                        }, {
+                            value: DateIntervals.LAST_MONTH,
+                            label: DateIntervals.LAST_MONTH,
+                        }, {
+                            value: DateIntervals.LAST_QUARTER,
+                            label: DateIntervals.LAST_QUARTER,
+                        }, {
+                            value: DateIntervals.LAST_YEAR,
+                            label: DateIntervals.LAST_YEAR,
+                        }]}
                     />
                 </Col>
             </Row>
diff --git a/cvat-ui/src/components/analytics-page/styles.scss b/cvat-ui/src/components/analytics-page/styles.scss
index 4bc8161fbf06..18acab536106 100644
--- a/cvat-ui/src/components/analytics-page/styles.scss
+++ b/cvat-ui/src/components/analytics-page/styles.scss
@@ -16,12 +16,18 @@
 }
 
 .cvat-task-quality-page,
+.cvat-analytics-overview,
 .cvat-project-quality-page {
     >.ant-row {
         margin-top: $grid-unit-size;
     }
 }
 
+.cvat-empty-performance-analytics-item {
+    display: flex;
+    justify-content: space-between;
+}
+
 .cvat-task-mean-annotation-quality {
     .ant-statistic {
         display: flex;
@@ -35,6 +41,10 @@
     }
 }
 
+.cvat-analytics-refresh-button {
+    margin-right: $grid-unit-size;
+}
+
 .cvat-analytics-card-title {
     font-size: 16px;
 }
diff --git a/cvat/apps/analytics_report/apps.py b/cvat/apps/analytics_report/apps.py
index f43c75a4b104..764a25b77d7c 100644
--- a/cvat/apps/analytics_report/apps.py
+++ b/cvat/apps/analytics_report/apps.py
@@ -9,16 +9,6 @@ class EventsConfig(AppConfig):
     name = "cvat.apps.analytics_report"
 
     def ready(self):
-        from django.conf import settings
-
-        from . import default_settings
-
-        for key in dir(default_settings):
-            if key.isupper() and not hasattr(settings, key):
-                setattr(settings, key, getattr(default_settings, key))
-
         from cvat.apps.iam.permissions import load_app_permissions
 
         load_app_permissions(self)
-
-        from . import signals  # pylint: disable=unused-import
diff --git a/cvat/apps/analytics_report/default_settings.py b/cvat/apps/analytics_report/default_settings.py
deleted file mode 100644
index 52e06e944a4d..000000000000
--- a/cvat/apps/analytics_report/default_settings.py
+++ /dev/null
@@ -1,8 +0,0 @@
-# Copyright (C) 2023 CVAT.ai Corporation
-#
-# SPDX-License-Identifier: MIT
-
-import os
-
-ANALYTICS_CHECK_JOB_DELAY = int(os.getenv("CVAT_ANALYTICS_CHECK_JOB_DELAY", 15 * 60))
-"The delay before the next analytics check job is queued, in seconds"
diff --git a/cvat/apps/analytics_report/permissions.py b/cvat/apps/analytics_report/permissions.py
index 41e0db50f5e4..9735fce22f14 100644
--- a/cvat/apps/analytics_report/permissions.py
+++ b/cvat/apps/analytics_report/permissions.py
@@ -4,6 +4,7 @@
 # SPDX-License-Identifier: MIT
 
 from django.conf import settings
+from django.core.exceptions import ObjectDoesNotExist
 from rest_framework.exceptions import ValidationError
 
 from cvat.apps.engine.models import Job, Project, Task
@@ -26,44 +27,41 @@ def create(cls, request, view, obj, iam_context):
                 self = cls.create_base_perm(request, view, scope, iam_context, obj)
                 permissions.append(self)
 
-            if view.action == Scopes.LIST:
-                job_id = request.query_params.get("job_id", None)
-                task_id = request.query_params.get("task_id", None)
-                project_id = request.query_params.get("project_id", None)
-            else:
-                job_id = request.data.get("job_id", None)
-                task_id = request.data.get("task_id", None)
-                project_id = request.data.get("project_id", None)
-
-            if job_id:
-                try:
-                    job = Job.objects.get(id=job_id)
-                except Job.DoesNotExist as ex:
-                    raise ValidationError(str(ex))
-
-                iam_context = get_iam_context(request, job)
-                perm = JobPermission.create_scope_view(iam_context, int(job_id))
-                permissions.append(perm)
-
-            if task_id:
-                try:
+            try:
+                if view.action == Scopes.LIST:
+                    job_id = request.query_params.get("job_id", None)
+                    task_id = request.query_params.get("task_id", None)
+                    project_id = request.query_params.get("project_id", None)
+
+                    if job_id:
+                        job = Job.objects.get(id=job_id)
+                        iam_context = get_iam_context(request, job)
+                        perm = JobPermission.create_scope_view(iam_context, int(job_id))
+                        permissions.append(perm)
+                else:
+                    job_id = request.data.get("job_id", None)
+                    task_id = request.data.get("task_id", None)
+                    project_id = request.data.get("project_id", None)
+
+                    if job_id:
+                        job = Job.objects.select_related("segment__task").get(id=job_id)
+                        task_id = job.segment.task.id
+
+                if task_id:
                     task = Task.objects.get(id=task_id)
-                except Task.DoesNotExist as ex:
-                    raise ValidationError(str(ex))
+                    iam_context = get_iam_context(request, task)
+                    perm = TaskPermission.create_scope_view(request, int(task_id), iam_context)
+                    permissions.append(perm)
 
-                iam_context = get_iam_context(request, task)
-                perm = TaskPermission.create_scope_view(request, int(task_id), iam_context)
-                permissions.append(perm)
-
-            if project_id:
-                try:
+                if project_id:
                     project = Project.objects.get(id=project_id)
-                except Project.DoesNotExist as ex:
-                    raise ValidationError(str(ex))
-
-                iam_context = get_iam_context(request, project)
-                perm = ProjectPermission.create_scope_view(iam_context, int(project_id))
-                permissions.append(perm)
+                    iam_context = get_iam_context(request, project)
+                    perm = ProjectPermission.create_scope_view(iam_context, int(project_id))
+                    permissions.append(perm)
+            except ObjectDoesNotExist as ex:
+                raise ValidationError(
+                    "The specified resource does not exist. Please check the provided identifiers"
+                ) from ex
 
         return permissions
 
diff --git a/cvat/apps/analytics_report/report/create.py b/cvat/apps/analytics_report/report/create.py
index 85d27ce96f6f..0ec4fdb2a7fb 100644
--- a/cvat/apps/analytics_report/report/create.py
+++ b/cvat/apps/analytics_report/report/create.py
@@ -1,10 +1,9 @@
-# Copyright (C) 2023 CVAT.ai Corporation
+# Copyright (C) 2023-2024 CVAT.ai Corporation
 #
 # SPDX-License-Identifier: MIT
 
-from datetime import datetime, timedelta
+from datetime import datetime
 from typing import Union
-from uuid import uuid4
 
 import django_rq
 from django.conf import settings
@@ -38,7 +37,6 @@
     PrimaryMetricBase,
 )
 from cvat.apps.engine.models import Job, Project, Task
-from cvat.utils.background_jobs import schedule_job_with_throttling
 
 
 def get_empty_report():
@@ -57,17 +55,9 @@ def get_empty_report():
 
 
 class AnalyticsReportUpdateManager:
-    _QUEUE_JOB_PREFIX_TASK = "update-analytics-report-task-"
-    _QUEUE_JOB_PREFIX_PROJECT = "update-analytics-report-project-"
-    _RQ_CUSTOM_ANALYTICS_CHECK_JOB_TYPE = "custom_analytics_check"
-    _JOB_RESULT_TTL = 120
-
-    @classmethod
-    def _get_analytics_check_job_delay(cls) -> timedelta:
-        return timedelta(seconds=settings.ANALYTICS_CHECK_JOB_DELAY)
-
-    def _get_scheduler(self):
-        return django_rq.get_scheduler(settings.CVAT_QUEUES.ANALYTICS_REPORTS.value)
+    _QUEUE_JOB_PREFIX_TASK = "analytics:calculate-report-task-"
+    _QUEUE_JOB_PREFIX_PROJECT = "analytics:calculate-report-project-"
+    _QUEUE_JOB_PREFIX_JOB = "analytics:calculate-report-job-"
 
     def _get_queue(self):
         return django_rq.get_queue(settings.CVAT_QUEUES.ANALYTICS_REPORTS.value)
@@ -75,11 +65,10 @@ def _get_queue(self):
     def _make_queue_job_id_base(self, obj) -> str:
         if isinstance(obj, Task):
             return f"{self._QUEUE_JOB_PREFIX_TASK}{obj.id}"
-        else:
+        elif isinstance(obj, Project):
             return f"{self._QUEUE_JOB_PREFIX_PROJECT}{obj.id}"
-
-    def _make_custom_analytics_check_job_id(self) -> str:
-        return uuid4().hex
+        elif isinstance(obj, Job):
+            return f"{self._QUEUE_JOB_PREFIX_JOB}{obj.id}"
 
     @classmethod
     def _get_last_report_time(cls, obj):
@@ -90,56 +79,24 @@ def _get_last_report_time(cls, obj):
         except ObjectDoesNotExist:
             return None
 
-    def schedule_analytics_report_autoupdate_job(self, *, job=None, task=None, project=None):
-        assert sum(map(bool, (job, task, project))) == 1, "Expected only 1 argument"
-
-        now = timezone.now()
-        delay = self._get_analytics_check_job_delay()
-        next_job_time = now.utcnow() + delay
-
-        target_obj = None
-        cvat_project_id = None
-        cvat_task_id = None
-        if job is not None:
-            if job.segment.task.project:
-                target_obj = job.segment.task.project
-                cvat_project_id = target_obj.id
-            else:
-                target_obj = job.segment.task
-                cvat_task_id = target_obj.id
-        elif task is not None:
-            if task.project:
-                target_obj = task.project
-                cvat_project_id = target_obj.id
-            else:
-                target_obj = task
-                cvat_task_id = target_obj.id
-        elif project is not None:
-            target_obj = project
-            cvat_project_id = project.id
-
-        schedule_job_with_throttling(
-            settings.CVAT_QUEUES.ANALYTICS_REPORTS.value,
-            self._make_queue_job_id_base(target_obj),
-            next_job_time,
-            self._check_analytics_report,
-            cvat_task_id=cvat_task_id,
-            cvat_project_id=cvat_project_id,
-        )
-
     def schedule_analytics_check_job(self, *, job=None, task=None, project=None, user_id):
-        rq_id = self._make_custom_analytics_check_job_id()
+        rq_id = self._make_queue_job_id_base(job or task or project)
 
         queue = self._get_queue()
+        existing_job = self.get_analytics_check_job(rq_id)
+
+        if existing_job:
+            if existing_job.get_status() in ["queued", "started", "deferred", "scheduled"]:
+                return rq_id
+            existing_job.delete()
+
         queue.enqueue(
             self._check_analytics_report,
             cvat_job_id=job.id if job is not None else None,
             cvat_task_id=task.id if task is not None else None,
             cvat_project_id=project.id if project is not None else None,
             job_id=rq_id,
-            meta={"user_id": user_id, "job_type": self._RQ_CUSTOM_ANALYTICS_CHECK_JOB_TYPE},
-            result_ttl=self._JOB_RESULT_TTL,
-            failure_ttl=self._JOB_RESULT_TTL,
+            meta={"user_id": user_id},
         )
 
         return rq_id
@@ -147,15 +104,8 @@ def schedule_analytics_check_job(self, *, job=None, task=None, project=None, use
     def get_analytics_check_job(self, rq_id: str):
         queue = self._get_queue()
         rq_job = queue.fetch_job(rq_id)
-
-        if rq_job and not self.is_custom_analytics_check_job(rq_job):
-            rq_job = None
-
         return rq_job
 
-    def is_custom_analytics_check_job(self, rq_job) -> bool:
-        return rq_job.meta.get("job_type") == self._RQ_CUSTOM_ANALYTICS_CHECK_JOB_TYPE
-
     @staticmethod
     def _get_analytics_report(db_obj: Union[Job, Task, Project]) -> AnalyticsReport:
         db_report = getattr(db_obj, "analytics_report", None)
diff --git a/cvat/apps/analytics_report/report/get.py b/cvat/apps/analytics_report/report/get.py
index 82622e5921a1..73674a370880 100644
--- a/cvat/apps/analytics_report/report/get.py
+++ b/cvat/apps/analytics_report/report/get.py
@@ -53,31 +53,27 @@ def _clamp_working_time(statistics):
 
 
 def _get_object_report(obj_model, pk, start_date, end_date):
+    data = {}
     try:
         db_obj = obj_model.objects.get(pk=pk)
         db_analytics_report = db_obj.analytics_report
+        data[f"{obj_model.__name__.lower()}_id"] = pk
     except obj_model.DoesNotExist as ex:
-        raise NotFound(f"{obj_model.__class__.__name__} object with pk={pk} does not exist") from ex
+        raise NotFound(f"{obj_model.__name__} object with pk={pk} does not exist") from ex
     except AnalyticsReport.DoesNotExist:
         db_analytics_report = get_empty_report()
 
     statistics = _filter_statistics_by_date(db_analytics_report.statistics, start_date, end_date)
     statistics = _convert_datetime_to_date(statistics)
-    statistics = _clamp_working_time(statistics)
+    data["statistics"] = _clamp_working_time(statistics)
+    data["created_date"] = db_analytics_report.created_date
 
     if obj_model is Job:
-        target = TargetChoice.JOB
+        data["target"] = TargetChoice.JOB
     elif obj_model is Task:
-        target = TargetChoice.TASK
+        data["target"] = TargetChoice.TASK
     elif obj_model is Project:
-        target = TargetChoice.PROJECT
-
-    data = {
-        "target": target,
-        f"{obj_model.__name__.lower()}_id": pk,
-        "statistics": statistics,
-        "created_date": db_analytics_report.created_date,
-    }
+        data["target"] = TargetChoice.PROJECT
     return data
 
 
diff --git a/cvat/apps/analytics_report/rules/analytics_reports.rego b/cvat/apps/analytics_report/rules/analytics_reports.rego
index b57dc764fcde..706d6e701dbe 100644
--- a/cvat/apps/analytics_report/rules/analytics_reports.rego
+++ b/cvat/apps/analytics_report/rules/analytics_reports.rego
@@ -30,6 +30,11 @@ allow if {
     utils.is_admin
 }
 
+allow if {
+    input.scope == utils.CREATE
+    utils.has_perm(utils.USER)
+}
+
 allow if {
     input.scope == utils.LIST
     utils.has_perm(utils.WORKER)
diff --git a/cvat/apps/analytics_report/signals.py b/cvat/apps/analytics_report/signals.py
deleted file mode 100644
index 5de53675a7c7..000000000000
--- a/cvat/apps/analytics_report/signals.py
+++ /dev/null
@@ -1,40 +0,0 @@
-# Copyright (C) 2023 CVAT.ai Corporation
-#
-# SPDX-License-Identifier: MIT
-
-from django.db import transaction
-from django.db.models.signals import post_save
-from django.dispatch import receiver
-
-from cvat.apps.analytics_report.report.create import AnalyticsReportUpdateManager
-from cvat.apps.engine.models import Annotation, Job, Project, Task
-
-
-@receiver(post_save, sender=Job, dispatch_uid=__name__ + ".save_job-update_analytics_report")
-@receiver(post_save, sender=Task, dispatch_uid=__name__ + ".save_task-update_analytics_report")
-@receiver(
-    post_save, sender=Project, dispatch_uid=__name__ + ".save_project-update_analytics_report"
-)
-@receiver(
-    post_save, sender=Annotation, dispatch_uid=__name__ + ".save_annotation-update_analytics_report"
-)
-def __save_job__update_analytics_report(instance, created, **kwargs):
-    if isinstance(instance, Project):
-        kwargs = {"project": instance}
-    elif isinstance(instance, Task):
-        kwargs = {"task": instance}
-    elif isinstance(instance, Job):
-        kwargs = {"job": instance}
-    elif isinstance(instance, Annotation):
-        kwargs = {"job": instance.job}
-    else:
-        assert False
-
-    def schedule_autoupdate_job():
-        if any(v.id is None for v in kwargs.values()):
-            # The object may have been deleted after the on_commit call.
-            return
-
-        AnalyticsReportUpdateManager().schedule_analytics_report_autoupdate_job(**kwargs)
-
-    transaction.on_commit(schedule_autoupdate_job, robust=True)
diff --git a/cvat/settings/development.py b/cvat/settings/development.py
index b6c02a83522f..2898fc88628f 100644
--- a/cvat/settings/development.py
+++ b/cvat/settings/development.py
@@ -65,6 +65,5 @@
 DATABASES['default']['HOST'] = os.getenv('CVAT_POSTGRES_HOST', 'localhost')
 
 QUALITY_CHECK_JOB_DELAY = 5
-ANALYTICS_CHECK_JOB_DELAY = 15
 
 SMOKESCREEN_ENABLED = False
diff --git a/cvat/settings/testing_rest.py b/cvat/settings/testing_rest.py
index 53427c8b8a6c..addda985492a 100644
--- a/cvat/settings/testing_rest.py
+++ b/cvat/settings/testing_rest.py
@@ -15,7 +15,6 @@
 # Note that DB initialization triggers server signals,
 # so quality report updates are scheduled for applicable jobs.
 QUALITY_CHECK_JOB_DELAY = 10000
-ANALYTICS_CHECK_JOB_DELAY = 10000
 
 IMPORT_CACHE_CLEAN_DELAY = timedelta(seconds=30)
 
diff --git a/docker-compose.dev.yml b/docker-compose.dev.yml
index 11d044b136c5..db9a8bbac01d 100644
--- a/docker-compose.dev.yml
+++ b/docker-compose.dev.yml
@@ -68,7 +68,6 @@ services:
 
   cvat_worker_analytics_reports:
     environment:
-      CVAT_ANALYTICS_CHECK_JOB_DELAY: 5
       # For debugging, make sure to set 1 process
       # Due to the supervisord specifics, the extra processes will fail and
       # after few attempts supervisord will give up restarting, leaving only 1 process
diff --git a/tests/cypress/e2e/features/analytics_pipeline.js b/tests/cypress/e2e/features/analytics_pipeline.js
index 9a354571a9fa..f8a5ba46927b 100644
--- a/tests/cypress/e2e/features/analytics_pipeline.js
+++ b/tests/cypress/e2e/features/analytics_pipeline.js
@@ -16,9 +16,11 @@ context('Analytics pipeline', () => {
 
     const taskName = 'Annotation task for testing performance analytics';
 
-    let projectID = null;
-    let jobID = null;
-    let taskID = null;
+    const data = {
+        projectID: null,
+        taskID: null,
+        jobID: null,
+    };
 
     const rectangles = [
         {
@@ -51,7 +53,7 @@ context('Analytics pipeline', () => {
     ];
 
     const cardEntryNames = ['annotation_time', 'total_object_count', 'total_annotation_speed'];
-    function checkCards(notNull) {
+    function checkCards() {
         cy.get('.cvat-analytics-card')
             .should('have.length', 3)
             .each((card) => {
@@ -59,7 +61,7 @@ context('Analytics pipeline', () => {
                     .invoke('data', 'entry-name')
                     .then((val) => {
                         expect(cardEntryNames.includes(val)).to.eq(true);
-                        if (notNull && ['total_object_count', 'total_annotation_speed'].includes(val)) {
+                        if (['total_object_count', 'total_annotation_speed'].includes(val)) {
                             cy.wrap(card).within(() => {
                                 cy.get('.cvat-analytics-card-value').should('not.have.text', '0.0');
                             });
@@ -78,24 +80,6 @@ context('Analytics pipeline', () => {
             });
     }
 
-    function waitForReport(authKey, rqID) {
-        cy.request({
-            method: 'POST',
-            url: `api/analytics/reports?rq_id=${rqID}`,
-            headers: {
-                Authorization: `Token ${authKey}`,
-            },
-            body: {
-                project_id: projectID,
-            },
-        }).then((response) => {
-            if (response.status === 201) {
-                return;
-            }
-            waitForReport(authKey, rqID);
-        });
-    }
-
     function openAnalytics(type) {
         if (['task', 'project'].includes(type)) {
             const actionsMenu = type === 'project' ? '.cvat-project-actions-menu' : '.cvat-actions-menu';
@@ -113,17 +97,20 @@ context('Analytics pipeline', () => {
     before(() => {
         cy.visit('auth/login');
         cy.login();
+        cy.get('.cvat-tasks-page').should('exist').and('be.visible');
+    });
 
+    beforeEach(() => {
         cy.headlessCreateProject({
             labels: projectLabels,
             name: projectName,
         }).then((response) => {
-            projectID = response.projectID;
+            data.projectID = response.projectID;
 
             cy.headlessCreateTask({
                 labels: [],
                 name: taskName,
-                project_id: projectID,
+                project_id: data.projectID,
                 source_storage: { location: 'local' },
                 target_storage: { location: 'local' },
             }, {
@@ -133,17 +120,24 @@ context('Analytics pipeline', () => {
                 use_cache: true,
                 sorting_method: 'lexicographical',
             }).then((taskResponse) => {
-                taskID = taskResponse.taskID;
-                [jobID] = taskResponse.jobIDs;
+                data.taskID = taskResponse.taskID;
+                [data.jobID] = taskResponse.jobIDs;
 
-                cy.visit(`/tasks/${taskID}`);
+                cy.visit(`/tasks/${data.taskID}`);
                 cy.get('.cvat-task-details').should('exist').and('be.visible');
             });
         });
     });
 
+    afterEach(() => {
+        if (data.projectID) {
+            cy.headlessDeleteProject(data.projectID);
+        }
+    });
+
     describe('Analytics pipeline', () => {
-        it('Check empty performance pages', () => {
+        it('Check all performance page to be empty', () => {
+            const { jobID, projectID, taskID } = data;
             cy.get('.cvat-job-item').contains('a', `Job #${jobID}`)
                 .parents('.cvat-job-item')
                 .find('.cvat-job-item-more-button')
@@ -153,22 +147,20 @@ context('Analytics pipeline', () => {
                 .within(() => {
                     cy.contains('[role="menuitem"]', 'View analytics').click();
                 });
-            checkCards();
-            checkHistograms();
+
+            cy.get('.cvat-empty-performance-analytics-item').should('exist').and('be.visible');
 
             cy.visit(`/projects/${projectID}`);
             openAnalytics('project');
-            checkCards();
-            checkHistograms();
+            cy.get('.cvat-empty-performance-analytics-item').should('exist').and('be.visible');
 
             cy.visit(`/tasks/${taskID}`);
             openAnalytics('task');
-            checkCards();
-            checkHistograms();
+            cy.get('.cvat-empty-performance-analytics-item').should('exist').and('be.visible');
         });
 
         it('Make some actions with objects, create analytics report, check performance pages', () => {
-            cy.visit(`/tasks/${taskID}`);
+            const { jobID, projectID, taskID } = data;
             cy.get('.cvat-job-item').contains('a', `Job #${jobID}`).click();
             cy.get('.cvat-spinner').should('not.exist');
 
@@ -194,36 +186,18 @@ context('Analytics pipeline', () => {
             cy.get('#cvat_canvas_shape_2').should('not.exist');
             cy.saveJob();
 
-            cy.logout();
-            cy.getAuthKey().then((res) => {
-                const authKey = res.body.key;
-                cy.request({
-                    method: 'POST',
-                    url: 'api/analytics/reports',
-                    headers: {
-                        Authorization: `Token ${authKey}`,
-                    },
-                    body: {
-                        project_id: projectID,
-                    },
-                }).then((response) => {
-                    const rqID = response.body.rq_id;
-                    waitForReport(authKey, rqID);
-                });
-            });
-            cy.login();
-            cy.intercept('GET', '/api/analytics/reports**').as('getReport');
-
             cy.visit(`/projects/${projectID}`);
             openAnalytics('project');
-            cy.wait('@getReport');
-            checkCards(true);
+            cy.get('.cvat-empty-performance-analytics-item').should('exist').and('be.visible').within(() => {
+                cy.get('button').contains('Request').click();
+            });
+
+            checkCards();
             checkHistograms();
 
             cy.visit(`/tasks/${taskID}`);
             openAnalytics('task');
-            cy.wait('@getReport');
-            checkCards(true);
+            checkCards();
             checkHistograms();
 
             cy.visit(`/tasks/${taskID}`);
@@ -239,8 +213,7 @@ context('Analytics pipeline', () => {
                 .find('[role="menuitem"]')
                 .filter(':contains("View analytics")')
                 .click();
-            cy.wait('@getReport');
-            checkCards(true);
+            checkCards();
             checkHistograms();
         });
     });
diff --git a/tests/cypress/e2e/features/ground_truth_jobs.js b/tests/cypress/e2e/features/ground_truth_jobs.js
index a3ef47de321d..6d3c9524d418 100644
--- a/tests/cypress/e2e/features/ground_truth_jobs.js
+++ b/tests/cypress/e2e/features/ground_truth_jobs.js
@@ -550,7 +550,7 @@ context('Ground truth jobs', () => {
             cy.contains('button', 'Submit').should('be.disabled');
             cy.wait('@delayedRequest');
 
-            cy.get('.cvat-spinner').should('not.exist');
+            cy.get('.cvat-canvas-container').should('exist').and('be.visible');
             cy.url().then((url) => {
                 jobID = Number(url.split('/').slice(-1)[0].split('?')[0]);
             }).should('match', /\/tasks\/\d+\/jobs\/\d+/);
diff --git a/tests/cypress/support/commands.js b/tests/cypress/support/commands.js
index 546aefd15a15..da393a99df70 100644
--- a/tests/cypress/support/commands.js
+++ b/tests/cypress/support/commands.js
@@ -300,6 +300,13 @@ Cypress.Commands.add('headlessCreateProject', (projectSpec) => {
     });
 });
 
+Cypress.Commands.add('headlessDeleteProject', (projectID) => {
+    cy.window().then(async ($win) => {
+        const [project] = await $win.cvat.projects.get({ id: projectID });
+        await project.delete();
+    });
+});
+
 Cypress.Commands.add('headlessCreateUser', (userSpec) => {
     cy.request({
         method: 'POST',