diff --git a/src/main/java/me/danjono/inventoryrollback/InventoryRollback.java b/src/main/java/me/danjono/inventoryrollback/InventoryRollback.java
index e4e98b7..bcc04fa 100644
--- a/src/main/java/me/danjono/inventoryrollback/InventoryRollback.java
+++ b/src/main/java/me/danjono/inventoryrollback/InventoryRollback.java
@@ -8,6 +8,7 @@
 import me.danjono.inventoryrollback.config.MessageData;
 import me.danjono.inventoryrollback.config.SoundData;
 import me.danjono.inventoryrollback.data.MySQL;
+import me.danjono.inventoryrollback.data.SQLite;
 import me.danjono.inventoryrollback.data.YAML;
 import me.danjono.inventoryrollback.listeners.ClickGUI;
 import me.danjono.inventoryrollback.listeners.EventLogs;
@@ -87,6 +88,12 @@ public void startupTasks() {
             } catch (SQLException e) {
                 e.printStackTrace();
             }
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            try {
+                new SQLite(null, null, (long) 0).createTables();
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
         }
 
         new MessageData().setMessages();    
diff --git a/src/main/java/me/danjono/inventoryrollback/config/ConfigData.java b/src/main/java/me/danjono/inventoryrollback/config/ConfigData.java
index 37426cb..91799cb 100644
--- a/src/main/java/me/danjono/inventoryrollback/config/ConfigData.java
+++ b/src/main/java/me/danjono/inventoryrollback/config/ConfigData.java
@@ -53,7 +53,8 @@ public boolean saveConfig() {
 
     public enum SaveType {
         YAML("YAML"),
-        MYSQL("MySQL");
+        MYSQL("MySQL"),
+        SQLITE("SQLite");
         
         private final String name;
 
@@ -115,11 +116,7 @@ public void setVariables() {
             }
         }
 
-        setMySQLEnabled((boolean) getDefaultValue("mysql.enabled", false));
-        if (isMySQLEnabled())
-            setSaveType(SaveType.MYSQL);
-        else
-            setSaveType(SaveType.YAML);
+        setSaveType((String) getDefaultValue("storage-type", "YAML"));
 
         setMySQLHost((String) getDefaultValue("mysql.details.host", "127.0.0.1"));
         setMySQLPort((int) getDefaultValue("mysql.details.port", 3306));
@@ -155,8 +152,20 @@ public static void setEnabled(boolean enabled) {
         pluginEnabled = enabled;
     }
 
-    public static void setSaveType(SaveType value) {
-        saveType = value;
+    public static void setSaveType(String value) {
+        if(value.equalsIgnoreCase("YAML")){
+            saveType = SaveType.YAML;
+        }
+        else if(value.equalsIgnoreCase("MySQL")){
+            saveType = SaveType.MYSQL;
+            setMySQLEnabled(saveType == SaveType.MYSQL);
+        }
+        else if(value.equalsIgnoreCase("SQLite")){
+            saveType = SaveType.SQLITE;
+        }
+        else{
+            saveType = SaveType.YAML; // Default to YAML
+        }
     }
 
     public static void setFolderLocation(File folder) {
diff --git a/src/main/java/me/danjono/inventoryrollback/data/PlayerData.java b/src/main/java/me/danjono/inventoryrollback/data/PlayerData.java
index dd717b7..ada2df1 100644
--- a/src/main/java/me/danjono/inventoryrollback/data/PlayerData.java
+++ b/src/main/java/me/danjono/inventoryrollback/data/PlayerData.java
@@ -26,6 +26,7 @@ public class PlayerData {
 
     private YAML yaml;
     private MySQL mysql;
+    private SQLite sqlite;
     
     public PlayerData(OfflinePlayer offlinePlayer, LogType logType, Long timestamp) {
         this.offlinePlayer = offlinePlayer;
@@ -36,6 +37,8 @@ public PlayerData(OfflinePlayer offlinePlayer, LogType logType, Long timestamp)
             yaml = new YAML(offlinePlayer.getUniqueId(), logType, timestamp);
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             mysql = new MySQL(offlinePlayer.getUniqueId(), logType, timestamp);
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            sqlite = new SQLite(offlinePlayer.getUniqueId(), logType, timestamp);
         }
     }
 
@@ -48,6 +51,8 @@ public PlayerData(UUID uuid, LogType logType, Long timestamp) {
             yaml = new YAML(uuid, logType, timestamp);
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             mysql = new MySQL(uuid, logType, timestamp);
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            sqlite = new SQLite(uuid, logType, timestamp);
         }
     }
         
@@ -73,6 +78,12 @@ public boolean doesBackupTypeExist() {
             } catch (SQLException e) {
                 e.printStackTrace();
             }
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE){
+            try {
+                return sqlite.doesBackupTypeExist();
+            } catch (SQLException e){
+                e.printStackTrace();
+            }
         }
 
         return false;
@@ -87,6 +98,12 @@ public int getAmountOfBackups() {
             } catch (SQLException e) {
                 e.printStackTrace();
             }
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            try {
+                return sqlite.getAmountOfBackups();
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
         }
 
         return 0;
@@ -103,6 +120,12 @@ public List<Long> getSelectedPageTimestamps(int pageNumber) {
             } catch (SQLException e) {
                 e.printStackTrace();
             }
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            try {
+                timeStamps = sqlite.getSelectedPageTimestamps(pageNumber);
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
         }
 
         return timeStamps;
@@ -128,6 +151,12 @@ public CompletableFuture<Void> purgeExcessSaves(boolean shouldSaveAsync) {
                     } catch (SQLException e) {
                         e.printStackTrace();
                     }
+                } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+                    try {
+                        sqlite.purgeExcessSaves(deleteAmount);
+                    } catch (SQLException e) {
+                        e.printStackTrace();
+                    }
                 }
             }
             future.complete(null);
@@ -145,6 +174,8 @@ public void setMainInventory(ItemStack[] items) {
             yaml.setMainInventory(items);
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             mysql.setMainInventory(items);
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            sqlite.setMainInventory(items);
         }
     }
 
@@ -153,6 +184,8 @@ public void setArmour(ItemStack[] items) {
             yaml.setArmour(items);
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             mysql.setArmour(items);
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            sqlite.setArmour(items);
         }
     }
 
@@ -161,6 +194,8 @@ public void setEnderChest(ItemStack[] items) {
             yaml.setEnderChest(items);
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             mysql.setEnderChest(items);
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            sqlite.setEnderChest(items);
         }
     }
 
@@ -169,6 +204,8 @@ public void setXP(float xp) {
             yaml.setXP(xp);
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             mysql.setXP(xp);
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            sqlite.setXP(xp);
         }
     }
 
@@ -177,6 +214,8 @@ public void setHealth(double health) {
             yaml.setHealth(health);
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             mysql.setHealth(health);
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            sqlite.setHealth(health);
         }
     }
 
@@ -185,6 +224,8 @@ public void setFoodLevel(int foodLevel) {
             yaml.setFoodLevel(foodLevel);
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             mysql.setFoodLevel(foodLevel);
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            sqlite.setFoodLevel(foodLevel);
         }
     }
 
@@ -193,6 +234,8 @@ public void setSaturation(float saturation) {
             yaml.setSaturation(saturation);
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             mysql.setSaturation(saturation);
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            sqlite.setSaturation(saturation);
         }
     }
 
@@ -201,6 +244,8 @@ public void setWorld(String world) {
             yaml.setWorld(world);
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             mysql.setWorld(world);
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            sqlite.setWorld(world);
         }
     }
 
@@ -209,6 +254,8 @@ public void setX(double x) {
             yaml.setX(x);
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             mysql.setX(x);
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            sqlite.setX(x);
         }
     }
 
@@ -217,6 +264,8 @@ public void setY(double y) {
             yaml.setY(y);
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             mysql.setY(y);
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            sqlite.setY(y);
         }
     }
 
@@ -225,6 +274,8 @@ public void setZ(double z) {
             yaml.setZ(z);
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             mysql.setZ(z);
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            sqlite.setZ(z);
         }
     }
 
@@ -239,6 +290,8 @@ public void setVersion(String packageVersion) {
             yaml.setVersion(packageVersion);
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             mysql.setVersion(packageVersion);
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            sqlite.setVersion(packageVersion);
         }
     }
 
@@ -247,6 +300,8 @@ public void setDeathReason(String deathReason) {
             yaml.setDeathReason(deathReason);
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             mysql.setDeathReason(deathReason);
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            sqlite.setDeathReason(deathReason);
         }
     }
 
@@ -257,6 +312,12 @@ public void getRollbackMenuData() {
             } catch (SQLException e) {
                 e.printStackTrace();
             }
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            try {
+                sqlite.getRollbackMenuData();
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
         }
     }
 
@@ -275,6 +336,19 @@ public void run() {
                 }
             }.runTaskAsynchronously(InventoryRollbackPlus.getInstance());
         }
+        else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            new BukkitRunnable() {
+                @Override
+                public void run() {
+                    try {
+                        sqlite.getAllBackupData();
+                    } catch (SQLException e) {
+                        e.printStackTrace();
+                    }
+                    future.complete(null);
+                }
+            }.runTaskAsynchronously(InventoryRollbackPlus.getInstance());
+        }
         return future;
     }
 
@@ -285,6 +359,8 @@ public ItemStack[] getMainInventory() {
             items = yaml.getMainInventory();
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             items = mysql.getMainInventory();
+        }  else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            items = sqlite.getMainInventory();
         }
 
         return items;
@@ -297,6 +373,8 @@ public ItemStack[] getArmour() {
             items = yaml.getArmour();
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             items = mysql.getArmour();
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            items = sqlite.getArmour();
         }
 
         return items;
@@ -309,6 +387,8 @@ public ItemStack[] getEnderChest() {
             items = yaml.getEnderChest();
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             items = mysql.getEnderChest();
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            items = sqlite.getEnderChest();
         }
 
         return items;
@@ -319,6 +399,8 @@ public float getXP() {
             return yaml.getXP();
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             return mysql.getXP();
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            return sqlite.getXP();
         }
 
         return 0;
@@ -329,6 +411,8 @@ public double getHealth() {
             return yaml.getHealth();
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             return mysql.getHealth();
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            return sqlite.getHealth();
         }
 
         return 0;
@@ -339,6 +423,8 @@ public int getFoodLevel() {
             return yaml.getFoodLevel();
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             return mysql.getFoodLevel();
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            return sqlite.getFoodLevel();
         }
 
         return 0;
@@ -349,6 +435,8 @@ public float getSaturation() {
             return yaml.getSaturation();
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             return mysql.getSaturation();
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            return sqlite.getSaturation();
         }
 
         return 0;
@@ -359,6 +447,8 @@ public String getWorld() {
             return yaml.getWorld();
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             return mysql.getWorld();
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            return sqlite.getWorld();
         }
 
         return null;
@@ -369,6 +459,8 @@ public double getX() {
             return yaml.getX();
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             return mysql.getX();
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            return sqlite.getX();
         }
 
         return 0;
@@ -379,6 +471,8 @@ public double getY() {
             return yaml.getY();
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             return mysql.getY();
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            return sqlite.getY();
         }
 
         return 0;
@@ -389,6 +483,8 @@ public double getZ() {
             return yaml.getZ();
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             return mysql.getZ();
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            return sqlite.getZ();
         }
 
         return 0;
@@ -407,6 +503,8 @@ public String getVersion() {
             return yaml.getVersion();
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             return mysql.getVersion();
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            return sqlite.getVersion();
         }
 
         return null;
@@ -417,6 +515,8 @@ public String getDeathReason() {
             return yaml.getDeathReason();
         } else if (ConfigData.getSaveType() == SaveType.MYSQL) {
             return mysql.getDeathReason();
+        } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+            return sqlite.getDeathReason();
         }
 
         return null;
@@ -434,6 +534,12 @@ public void saveData(boolean shouldSaveAsync) {
                 } catch (SQLException e) {
                     e.printStackTrace();
                 }
+            } else if (ConfigData.getSaveType() == SaveType.SQLITE) {
+                try {
+                    sqlite.saveData();
+                } catch (SQLException e) {
+                    e.printStackTrace();
+                }
             }
         };
 
diff --git a/src/main/java/me/danjono/inventoryrollback/data/SQLite.java b/src/main/java/me/danjono/inventoryrollback/data/SQLite.java
new file mode 100644
index 0000000..6489a13
--- /dev/null
+++ b/src/main/java/me/danjono/inventoryrollback/data/SQLite.java
@@ -0,0 +1,439 @@
+package me.danjono.inventoryrollback.data;
+
+import java.io.File;
+import java.io.IOException;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+import org.bukkit.inventory.ItemStack;
+
+import me.danjono.inventoryrollback.config.ConfigData;
+import me.danjono.inventoryrollback.gui.InventoryName;
+import me.danjono.inventoryrollback.inventory.RestoreInventory;
+import me.danjono.inventoryrollback.inventory.SaveInventory;
+
+public class SQLite {
+
+    private final UUID uuid;
+    private final Long timestamp;
+    private final BackupTable backupTable;
+
+    public enum BackupTable {
+        DEATH("deaths"),
+        JOIN("joins"),
+        QUIT("quits"),
+        WORLD_CHANGE("world_changes"),
+        FORCE("force_backups");
+
+        private final String tableName;
+
+        BackupTable(String tableName) {
+            this.tableName = tableName;
+        }
+
+        public String getTableName() {
+            return this.tableName;
+        }
+    }
+
+    private Connection connection;
+
+    private String mainInventory;
+    private String armour;
+    private String enderChest;
+    private float xp;
+    private double health;
+    private int hunger;
+    private float saturation;
+    private String world;
+    private double x;
+    private double y;
+    private double z;
+    private final LogType logType;
+    private String packageVersion;
+    private String deathReason;
+
+    public SQLite(UUID uuid, LogType logType, Long timestamp) {
+        this.uuid = uuid;
+        this.logType = logType;
+        this.timestamp = timestamp;
+        this.backupTable = getBackupTable();
+
+
+    }
+
+    public void openConnection() throws SQLException {
+        if (connection != null && !connection.isClosed()) {
+            return;
+        }
+
+        synchronized (this) {
+            File dbFile = new File(ConfigData.getFolderLocation(), "database.db");
+
+            // Create parent directories if they don't exist
+            if (!dbFile.getParentFile().exists()) {
+                dbFile.getParentFile().mkdirs();
+            }
+
+            // Create the database file if it doesn't exist
+            if (!dbFile.exists()) {
+                try {
+                    dbFile.createNewFile();
+                } catch (IOException e) {
+                    throw new SQLException("Could not create database file", e);
+                }
+            }
+
+            connection = DriverManager.getConnection("jdbc:sqlite:" + dbFile.getAbsolutePath());
+        }
+    }
+
+    public void closeConnection() throws SQLException {
+        if (connection != null && !connection.isClosed()) {
+            connection.close();
+        }
+    }
+
+    public void createTables() throws SQLException {
+        openConnection();
+
+        try {
+            for (BackupTable table : BackupTable.values()) {
+                String tableQuery = "CREATE TABLE IF NOT EXISTS " + table.getTableName() + " (" +
+                        "id INTEGER PRIMARY KEY AUTOINCREMENT," +
+                        "uuid TEXT NOT NULL," +
+                        "timestamp INTEGER NOT NULL," +
+                        "xp REAL NOT NULL," +
+                        "health REAL NOT NULL," +
+                        "hunger INTEGER NOT NULL," +
+                        "saturation REAL NOT NULL," +
+                        "location_world TEXT NOT NULL," +
+                        "location_x REAL NOT NULL," +
+                        "location_y REAL NOT NULL," +
+                        "location_z REAL NOT NULL," +
+                        "version TEXT NOT NULL," +
+                        "death_reason TEXT," +
+                        "main_inventory BLOB," +
+                        "armour BLOB," +
+                        "ender_chest BLOB" +
+                        ");";
+
+                try (PreparedStatement statement = connection.prepareStatement(tableQuery)) {
+                    statement.executeUpdate();
+                }
+            }
+        } finally {
+            closeConnection();
+        }
+    }
+
+    private BackupTable getBackupTable() {
+        if (logType == LogType.JOIN) {
+            return BackupTable.JOIN;
+        } else if (logType == LogType.QUIT) {
+            return BackupTable.QUIT;
+        } else if (logType == LogType.DEATH) {
+            return BackupTable.DEATH;
+        } else if (logType == LogType.WORLD_CHANGE) {
+            return BackupTable.WORLD_CHANGE;
+        } else if (logType == LogType.FORCE) {
+            return BackupTable.FORCE;
+        }
+
+        return null;
+    }
+
+    public boolean doesBackupTypeExist() throws SQLException {
+        openConnection();
+
+        try {
+            String query = "SELECT 1 FROM " + backupTable.getTableName() + " WHERE uuid = ? LIMIT 1";
+
+            try (PreparedStatement statement = connection.prepareStatement(query)) {
+                statement.setString(1, uuid.toString());
+
+                try (ResultSet results = statement.executeQuery()) {
+                    // return results.next();
+                    return  true;
+                }
+            }
+        } finally {
+            closeConnection();
+        }
+    }
+
+    public int getAmountOfBackups() throws SQLException {
+        openConnection();
+
+        try {
+            String query = "SELECT COUNT(id) FROM " + backupTable.getTableName() + " WHERE uuid = ?";
+
+            try (PreparedStatement statement = connection.prepareStatement(query)) {
+                statement.setString(1, uuid.toString());
+
+                try (ResultSet results = statement.executeQuery()) {
+                    results.next();
+                    return results.getInt(1);
+                }
+            }
+        } finally {
+            closeConnection();
+        }
+    }
+
+    public List<Long> getSelectedPageTimestamps(int pageNumber) throws SQLException {
+        openConnection();
+
+        List<Long> timeStamps = new ArrayList<>();
+        int backups = InventoryName.ROLLBACK_LIST.getSize() - 9;
+
+        try {
+            int queryRange = ((pageNumber - 1) * backups);
+            if (queryRange < 0)
+                queryRange = 0;
+
+            String query = "SELECT timestamp FROM " + backupTable.getTableName() +
+                    " WHERE uuid = ? ORDER BY timestamp DESC LIMIT ? OFFSET ?";
+
+            try (PreparedStatement statement = connection.prepareStatement(query)) {
+                statement.setString(1, uuid.toString());
+                statement.setInt(2, backups);
+                statement.setInt(3, queryRange);
+
+                try (ResultSet results = statement.executeQuery()) {
+                    while (results.next()) {
+                        timeStamps.add(results.getLong(1));
+                    }
+                }
+            }
+
+            return timeStamps;
+        } finally {
+            closeConnection();
+        }
+    }
+
+    public void purgeExcessSaves(int deleteAmount) throws SQLException {
+        openConnection();
+
+        try {
+            String delete = "DELETE FROM " + backupTable.getTableName() +
+                    " WHERE id IN (SELECT id FROM " + backupTable.getTableName() +
+                    " WHERE uuid = ? ORDER BY timestamp ASC LIMIT ?)";
+
+            try (PreparedStatement statement = connection.prepareStatement(delete)) {
+                statement.setString(1, uuid.toString());
+                statement.setInt(2, deleteAmount);
+                statement.executeUpdate();
+            }
+        } finally {
+            closeConnection();
+        }
+    }
+
+    // Setters remain the same
+    public void setMainInventory(ItemStack[] items) {
+        this.mainInventory = SaveInventory.toBase64(items);
+    }
+
+    public void setArmour(ItemStack[] items) {
+        this.armour = SaveInventory.toBase64(items);
+    }
+
+    public void setEnderChest(ItemStack[] items) {
+        this.enderChest = SaveInventory.toBase64(items);
+    }
+
+    public void setXP(float xp) {
+        this.xp = xp;
+    }
+
+    public void setHealth(double health) {
+        this.health = health;
+    }
+
+    public void setFoodLevel(int foodLevel) {
+        this.hunger = foodLevel;
+    }
+
+    public void setSaturation(float saturation) {
+        this.saturation = saturation;
+    }
+
+    public void setWorld(String world) {
+        this.world = world;
+    }
+
+    public void setX(double x) {
+        this.x = x;
+    }
+
+    public void setY(double y) {
+        this.y = y;
+    }
+
+    public void setZ(double z) {
+        this.z = z;
+    }
+
+    public void setVersion(String packageVersion) {
+        this.packageVersion = packageVersion;
+    }
+
+    public void setDeathReason(String deathReason) {
+        this.deathReason = deathReason;
+    }
+
+    public void getRollbackMenuData() throws SQLException {
+        openConnection();
+
+        try {
+            String query = "SELECT timestamp, death_reason, location_world, location_x, location_y, location_z " +
+                    "FROM " + backupTable.getTableName() + " WHERE uuid = ? AND timestamp = ?";
+
+            try (PreparedStatement statement = connection.prepareStatement(query)) {
+                statement.setString(1, uuid.toString());
+                statement.setLong(2, timestamp);
+
+                try (ResultSet results = statement.executeQuery()) {
+                    if (results.next()) {
+                        world = results.getString("location_world");
+                        x = results.getDouble("location_x");
+                        y = results.getDouble("location_y");
+                        z = results.getDouble("location_z");
+                        deathReason = results.getString("death_reason");
+                    }
+                }
+            }
+        } finally {
+            closeConnection();
+        }
+    }
+
+    public void getAllBackupData() throws SQLException {
+        openConnection();
+
+        try {
+            String query = "SELECT * FROM " + backupTable.getTableName() +
+                    " WHERE uuid = ? AND timestamp = ?";
+
+
+            try (PreparedStatement statement = connection.prepareStatement(query)) {
+                statement.setString(1, uuid.toString());
+                statement.setLong(2, timestamp);
+
+                try (ResultSet results = statement.executeQuery()) {
+                    if (results.next()) {
+                        mainInventory = results.getString("main_inventory");
+                        armour = results.getString("armour");
+                        enderChest = results.getString("ender_chest");
+                        xp = results.getFloat("xp");
+                        health = results.getDouble("health");
+                        hunger = results.getInt("hunger");
+                        saturation = results.getFloat("saturation");
+                        world = results.getString("location_world");
+                        x = results.getDouble("location_x");
+                        y = results.getDouble("location_y");
+                        z = results.getDouble("location_z");
+                        packageVersion = results.getString("version");
+                        deathReason = results.getString("death_reason");
+                    }
+                }
+            }
+        } finally {
+            closeConnection();
+        }
+    }
+
+    // Getters remain the same
+    public ItemStack[] getMainInventory() {
+        return RestoreInventory.getInventoryItems(packageVersion, mainInventory);
+    }
+
+    public ItemStack[] getArmour() {
+        return RestoreInventory.getInventoryItems(packageVersion, armour);
+    }
+
+    public ItemStack[] getEnderChest() {
+        return RestoreInventory.getInventoryItems(packageVersion, enderChest);
+    }
+
+    public float getXP() {
+        return this.xp;
+    }
+
+    public double getHealth() {
+        return this.health;
+    }
+
+    public int getFoodLevel() {
+        return this.hunger;
+    }
+
+    public float getSaturation() {
+        return this.saturation;
+    }
+
+    public String getWorld() {
+        return this.world;
+    }
+
+    public double getX() {
+        return this.x;
+    }
+
+    public double getY() {
+        return this.y;
+    }
+
+    public double getZ() {
+        return this.z;
+    }
+
+    public String getVersion() {
+        return this.packageVersion;
+    }
+
+    public String getDeathReason() {
+        return this.deathReason;
+    }
+
+    public void saveData() throws SQLException {
+        openConnection();
+
+        try {
+            String update = "INSERT INTO " + backupTable.getTableName() +
+                    "(uuid, timestamp, xp, health, hunger, saturation, location_world, " +
+                    "location_x, location_y, location_z, version, death_reason, " +
+                    "main_inventory, armour, ender_chest) " +
+                    "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
+
+            try (PreparedStatement statement = connection.prepareStatement(update)) {
+                statement.setString(1, uuid.toString());
+                statement.setLong(2, timestamp);
+                statement.setFloat(3, xp);
+                statement.setDouble(4, health);
+                statement.setInt(5, hunger);
+                statement.setFloat(6, saturation);
+                statement.setString(7, world);
+                statement.setDouble(8, x);
+                statement.setDouble(9, y);
+                statement.setDouble(10, z);
+                statement.setString(11, packageVersion);
+                statement.setString(12, deathReason);
+                statement.setString(13, mainInventory);
+                statement.setString(14, armour);
+                statement.setString(15, enderChest);
+                statement.executeUpdate();
+            }
+        } finally {
+            closeConnection();
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/me/danjono/inventoryrollback/inventory/RestoreInventory.java b/src/main/java/me/danjono/inventoryrollback/inventory/RestoreInventory.java
index 97409f7..7b94688 100644
--- a/src/main/java/me/danjono/inventoryrollback/inventory/RestoreInventory.java
+++ b/src/main/java/me/danjono/inventoryrollback/inventory/RestoreInventory.java
@@ -40,6 +40,7 @@ public static ItemStack[] getInventoryItems(String packageVersion, String base64
     }
 
     private static ItemStack[] stacksFromBase64(String packageVersion, String data) {
+
         if (data == null)
             return new ItemStack[]{};
 
@@ -61,8 +62,10 @@ private static ItemStack[] stacksFromBase64(String packageVersion, String data)
             e1.printStackTrace();
         }
 
-        if (stacks == null)
+        if (stacks == null) {
             return new ItemStack[]{};
+        }
+
 
         for (int i = 0; i < stacks.length; i++) {
             try {
diff --git a/src/main/java/me/danjono/inventoryrollback/listeners/ClickGUI.java b/src/main/java/me/danjono/inventoryrollback/listeners/ClickGUI.java
index 9314940..24b22e3 100644
--- a/src/main/java/me/danjono/inventoryrollback/listeners/ClickGUI.java
+++ b/src/main/java/me/danjono/inventoryrollback/listeners/ClickGUI.java
@@ -205,7 +205,7 @@ public void run() {
                         PlayerData data = new PlayerData(uuid, logType, timestamp);
 
                         // Get from MySQL
-                        if (ConfigData.getSaveType() == ConfigData.SaveType.MYSQL) {
+                        if (ConfigData.getSaveType() == ConfigData.SaveType.MYSQL || ConfigData.getSaveType() == ConfigData.SaveType.SQLITE) {
                             try {
                                 data.getAllBackupData().get();
                             } catch (ExecutionException | InterruptedException ex) {
@@ -297,7 +297,7 @@ public void run() {
                             PlayerData data = new PlayerData(offlinePlayer, logType, timestamp);
 
                             // Get data if using MySQL
-                            if (ConfigData.getSaveType() == ConfigData.SaveType.MYSQL) {
+                            if (ConfigData.getSaveType() == ConfigData.SaveType.MYSQL || ConfigData.getSaveType() == ConfigData.SaveType.SQLITE) {
                                 try {
                                     data.getAllBackupData().get();
                                 } catch (ExecutionException | InterruptedException ex) {
@@ -389,7 +389,7 @@ public void run() {
                         PlayerData data = new PlayerData(offlinePlayer, logType, timestamp);
 
                         // Get data if using MySQL
-                        if (ConfigData.getSaveType() == ConfigData.SaveType.MYSQL) {
+                        if (ConfigData.getSaveType() == ConfigData.SaveType.MYSQL || ConfigData.getSaveType() == ConfigData.SaveType.SQLITE) {
                             try {
                                 data.getAllBackupData().get();
                             } catch (ExecutionException | InterruptedException ex) {
@@ -550,7 +550,7 @@ public void run() {
                             PlayerData data = new PlayerData(offlinePlayer, logType, timestamp);
 
                             // Get data if using MySQL
-                            if (ConfigData.getSaveType() == ConfigData.SaveType.MYSQL) {
+                            if (ConfigData.getSaveType() == ConfigData.SaveType.MYSQL || ConfigData.getSaveType() == ConfigData.SaveType.SQLITE) {
                                 try {
                                     data.getAllBackupData().get();
                                 } catch (ExecutionException | InterruptedException ex) {
@@ -587,7 +587,7 @@ public void run() {
                             PlayerData data = new PlayerData(offlinePlayer, logType, timestamp);
 
                             // Get data if using MySQL
-                            if (ConfigData.getSaveType() == ConfigData.SaveType.MYSQL) {
+                            if (ConfigData.getSaveType() == ConfigData.SaveType.MYSQL || ConfigData.getSaveType() == ConfigData.SaveType.SQLITE) {
                                 try {
                                     data.getAllBackupData().get();
                                 } catch (ExecutionException | InterruptedException ex) {
@@ -636,7 +636,7 @@ public void run() {
                             PlayerData data = new PlayerData(offlinePlayer, logType, timestamp);
 
                             // Get from MySQL
-                            if (ConfigData.getSaveType() == ConfigData.SaveType.MYSQL) {
+                            if (ConfigData.getSaveType() == ConfigData.SaveType.MYSQL || ConfigData.getSaveType() == ConfigData.SaveType.SQLITE) {
                                 try {
                                     data.getAllBackupData().get();
                                 } catch (ExecutionException | InterruptedException ex) {
@@ -644,6 +644,7 @@ public void run() {
                                 }
                             }
 
+
                             // Display inventory to player
                             Future<Void> inventoryReplaceFuture = main.getServer().getScheduler().callSyncMethod(main,
                                     () -> {
diff --git a/src/main/resources/config.yml b/src/main/resources/config.yml
index 9b11dfd..7a08efb 100644
--- a/src/main/resources/config.yml
+++ b/src/main/resources/config.yml
@@ -15,10 +15,11 @@ backup-lines-visible: 4
 ## Set folder path where the data is saved to. Set as "DEFAULT" to keep it in the plugin folder.
 folder-location: 'DEFAULT'
 
-## If enabled, this will disable YAML file backups in favour of MySQL storage.
-## Requires a MySQL server.
+# The following storage types are possible: YAML, MySQL, SQLite
+storage-type: YAML
+
+# If you are using MySQL for the storage type, you will need to feel in your database credentials
 mysql:
-  enabled: false
   details:
     host: 'localhost'
     port: 3306