DataStore request was added to queue. If request queue fills, further Try sending fewer requests??

Solution

This is where RequestBudget comes in. If there isn't enough RequestBudget, it will show that warning. To fix that, you will need to wait until there is enough budget.

local function waitForRequestBudget(requestType: Enum.DataStoreRequestType)
    local currentBudget = DataStoreService:GetRequestBudgetForRequestType(requestType)
    while currentBudget < 1 do
        currentBudget = DataStoreService:GetRequestBudgetForRequestType(requestType)
        task.wait(5)
    end
end

Now you can use that function in GetAsync() and SetAsync().

-- House Data --
waitForRequestBudget(Enum.DataStoreRequestType.GetAsync)
local houseData = HouseData:GetAsync(player.UserId) or {}

-- House Saving --
waitForRequestBudget(Enum.DataStoreRequestType.SetAsync)
HouseData:SetAsync(player.UserId, Houses)

Pcall (Protected Call)

I recommend using a pcall() when using an asynchronous function since they can error and break the script. pcall() calls a function and if it errors, it won't affect the script and the error message will just get returned by pcall(). If it didn't error and it was successful, pcall() will return everything returned by the called function.

-- House Data --
waitForRequestBudget(Enum.DataStoreRequestType.GetAsync)

local success, houseData = pcall(function()
    return HouseData:GetAsync(player.UserId)
end)
-- or
local success, houseData = pcall(HouseData.GetAsync, HouseData, player.UserId)

if success == true then -- if successful
    for houseName, houseValue in pairs(HouseData) 
        Houses[houseName].Value = houseValue
    end
else -- if it errors (mostly when player has no data)
    print("Player " .. Player.Name .. " has no data!")
    warn(houseData) -- warns the error message
end

Retries

If you use SetAsync() once, there's a chance it might error, not saving the data. What you can do is retry until data is saved.

-- House Saving --
local success
repeat
    waitForRequestBudget(Enum.DataStoreRequestType.SetAsync)
    success = pcall(HouseData.SetAsync, HouseData player.UserId, Houses)
until success == true

UpdateAsync > SetAsync

UpdateAsync() is safer to use in multi-server attempts than SetAsync(), so you should use it except when using an OrderedDataStore (commonly used in global leaderboards).

-- House Saving --
local success
repeat
    waitForRequestBudget(Enum.DataStoreRequestType.UpdateAsync)
    success = pcall(HouseData.UpdateAsync, HouseData, player.UserId, function()
        return Houses
    end)
until success == true

Final Script

local DataStoreService = game:GetService("DataStoreService")
local MainData = DataStoreService:GetDataStore("MainData")
local HouseData = DataStoreService:GetDataStore("HouseData")

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")

local function waitForRequestBudget(requestType: Enum.DataStoreRequestType)
    local currentBudget = DataStoreService:GetRequestBudgetForRequestType(requestType)
    while currentBudget < 1 do
        currentBudget = DataStoreService:GetRequestBudgetForRequestType(requestType)
        task.wait(5)
    end
end

-- House Data --
function loadHouseData(player: Player?)
    local Plot = Instance.new("StringValue")
    Plot.Name = "Plot"
    Plot.Value = ""
    Plot.Parent = player

    local Houses = Instance.new("Folder")
    Houses.Name = "Houses"
    Houses.Parent = player

    for i, house in pairs(ReplicatedStorage.Houses:GetChildren()) do
        local newValue = Instance.new("BoolValue")
        newValue.Name = house.Name
        newValue.Value = false
        newValue.Parent = Houses
    end

    waitForRequestBudget(Enum.DataStoreRequestType.GetAsync)
    local success, houseData
    local retries = 0
    repeat
        waitForRequestBudget(Enum.DataStoreRequestType.GetAsync)
        success, houseData = pcall(HouseData.GetAsync, HouseData, player.UserId)
        retries += 1
    until (success and houseData) or retries >= 5

    if success then
        for houseName, houseValue in pairs(houseData) do
            Houses[houseName].Value = houseValue
        end
    else -- if it errors (mostly when player has no data)
        print("Player " .. Player.Name .. " has no data!")
        warn(houseData) -- warns the error message
    end
end

-- House Saving --
function saveHouseData(player: Player, dontWait: boolean?)
    if workspace:FindFirstChild(player.Name.."'sHouse") then
        workspace:FindFirstChild(player.Name.."'sHouse"):Destroy()
    end

    local PlayerPlot = player.Plot
    workspace:FindFirstChild(PlayerPlot.Value).CurrentOwner.Value = ""
    player.Plot.Value = ""

    local Houses = {}

    for i, value in pairs(player.Houses:GetChildren()) do
        Houses[value.Name] = value.Value
    end

    local success
    repeat
        if not dontWait then
            waitForRequestBudget(Enum.DataStoreRequestType.UpdateAsync)
        end
        success = pcall(HouseData.UpdateAsync, HouseData, player.UserId, function()
            return Houses
        end)
    until success
end

for _, player in ipairs(Players:GetPlayers()) do
    coroutine.wrap(loadHouseData)(player)
end

Players.PlayerAdded:Connect(loadHouseData)
Players.PlayerRemoving:Connect(saveHouseData)

game:BindToClose(function()
    if RunService:IsStudio() then
        task.wait(2)
    else
        local finished = Instance.new("BindableEvent")
        local allPlayers = Players:GetPlayers()
        local leftPlayers = #allPlayers

        for _, player in ipairs(allPlayers) do
            coroutine.wrap(function()
                saveHouseData(player, true)
                leftPlayers -= 1
                if leftPlayers == 0 then
                    finished:Fire()
                end
            end)()
        end

        finished.Event:Wait()
    end
end)

Source