Full Stack System 2026

Smart Backup & File integrity Manager

A C++17 and Qt 6 desktop application for creating verified backups, restoring files, maintaining backup history, and detecting file changes through SHA-256 integrity checking. The project was developed while expanding from console-based C++ programming into event-driven Qt desktop application development.

C++17 Qt 6 Qt Widgets QThread Qt SQL SQLite CMake SHA-256 QSS Git Inno Setup

Smart Backup & File integrity Manager project preview

Project Overview

Engineering the solution

Smart Backup & File Integrity Manager is a Windows desktop application built with C++17 and Qt 6 to explore practical desktop software development beyond console applications. The system allows users to select source and destination directories, create recursive timestamped backups, verify copied files using SHA-256 hashes, restore previous backups, and maintain a persistent record of backup operations using SQLite. Each backup can also contain an integrity manifest storing file hashes. The application can later scan the selected backup and identify unchanged, modified, missing, or newly added files. Long-running backup, restore, and integrity operations execute on worker threads so that the Qt interface remains responsive while progress is reported back to the user.

The Problem

Basic file copying provides little information about whether a backup completed correctly or whether the stored files remain unchanged over time. Large file operations can also block a desktop application's main thread, causing the interface to freeze. Backup records are often lost between sessions unless they are persisted separately. The project therefore focused on several practical problems: safely copying directory structures, verifying copied data, detecting later changes, keeping the GUI responsive during long operations, storing backup history, and providing a controlled restore workflow.

The Solution

The application implements a service-based backup workflow using Qt filesystem APIs. BackupService recursively scans the selected source directory and recreates its structure inside a timestamped backup directory. HashService calculates SHA-256 hashes to verify that source and copied files match. Backup, restore, and integrity operations are executed through dedicated worker objects running on QThread instances. Workers communicate with MainWindow using Qt signals and slots, allowing progress updates without directly manipulating GUI elements from background threads. SQLite is used to persist backup history including source and destination paths, timestamps, file counts, verification results, status, and operation duration. For integrity monitoring, each new backup stores a JSON manifest containing relative file paths and SHA-256 hashes. Later scans compare the backup against this baseline and classify files as unchanged, modified, missing, or new. The application also provides a safe restore process that recreates the backed-up directory structure and verifies restored files after copying.

Core Capabilities

What the system delivers

Recursive Folder Backup

SHA-256 File Verification

Backup Integrity Manifest

Modified / Missing / New File Detection

Asynchronous Processing with QThread

Live Backup and Restore Progress

SQLite Backup History

Backup Restore with Verification

Responsive Qt Desktop Interface

Windows Deployment with windeployqt

Windows Installer Packaging with Inno Setup

System Architecture

How the system is structured

The application follows a small layered architecture that separates user-interface responsibilities from file-processing and persistence logic. MainWindow manages user interaction, validation, progress display, backup history, and operation state. BackupWorker, RestoreWorker, and IntegrityWorker act as the asynchronous execution layer. Each worker runs within a QThread and communicates with the GUI using Qt's signals and slots mechanism. BackupService handles recursive backup operations, RestoreService handles restoration, and IntegrityService manages integrity manifests and file comparison. HashService provides reusable SHA-256 hashing and verification functionality across backup, restore, and integrity operations. DatabaseManager provides the persistence layer using Qt SQL and SQLite, while BackupRecord represents stored backup-history data. The resulting flow is: UI → Signals/Slots → QThread Worker → Service Layer → Filesystem / SHA-256 / SQLite Qt resources are used to embed application assets and QSS styling, CMake manages the build, windeployqt handles Windows runtime deployment, and Inno Setup is used to package the final Windows installer.

More Engineering Work

Explore the complete project portfolio.

View All Projects