10 Excel VBA Tricks That Will Save You Hours Every Week

I have spent years building Excel solutions for clients on Upwork, and the same pattern keeps coming up: smart people burning hours every week on tasks that a short VBA macro could handle in seconds. Excel's built-in features are powerful, but VBA is where the real productivity gains live.

VBA (Visual Basic for Applications) is Excel's built-in programming language. You access it through Alt + F11 or Developer > Visual Basic. If you have never written a macro before, don't worry — every trick in this article includes copy-paste-ready code that you can adapt to your own workbooks.

Here are 10 VBA tricks I use constantly and recommend to every client who wants to stop doing things the hard way.

1 Auto-Save Workbooks on a Timer

We have all lost work because we forgot to hit Ctrl+S. This macro saves your workbook automatically at whatever interval you choose — every 5 minutes, every 10 minutes, whatever makes sense. It runs silently in the background so you never have to think about it.

How It Works

The macro uses Application.OnTime to schedule itself to run repeatedly. Drop it into the ThisWorkbook module so it starts automatically when you open the file.

' Place this in the ThisWorkbook module
Private Sub Workbook_Open()
    Call StartAutoSave
End Sub

Private Sub Workbook_BeforeClose(Cancel As Boolean)
    Call StopAutoSave
End Sub

' Place these in a standard module
Public RunTime As Date

Sub StartAutoSave()
    RunTime = Now + TimeValue("00:05:00") ' Save every 5 minutes
    Application.OnTime RunTime, "AutoSaveWorkbook"
End Sub

Sub AutoSaveWorkbook()
    If Not ThisWorkbook.ReadOnly Then
        ThisWorkbook.Save
        Application.StatusBar = "Auto-saved at " & Format(Now, "h:mm:ss AM/PM")
    End If
    Call StartAutoSave ' Schedule the next save
End Sub

Sub StopAutoSave()
    On Error Resume Next
    Application.OnTime RunTime, "AutoSaveWorkbook", , False
    Application.StatusBar = False
    On Error GoTo 0
End Sub

Change the TimeValue to adjust the interval. I typically recommend 5 minutes for workbooks with active data entry and 10 minutes for dashboards and reports.

Pro tip: The status bar message gives you peace of mind — you can glance at the bottom of Excel anytime and see exactly when the last auto-save happened.

2 One-Click Data Cleanup Macro

Dirty data is the silent killer of every spreadsheet workflow. Extra spaces, inconsistent capitalization, duplicate rows — these problems compound fast when multiple people are entering data. This macro handles all three cleanups in a single click.

How It Works

Select any range of cells, run the macro, and it will trim leading/trailing spaces, convert text to proper case, and remove duplicate rows. It reports exactly what it did when it finishes.

Sub CleanupData()
    Dim rng As Range
    Dim cell As Range
    Dim ws As Worksheet
    Dim trimCount As Long
    Dim caseCount As Long
    Dim dupCount As Long
    Dim lastRow As Long
    Dim lastCol As Long

    Set ws = ActiveSheet

    ' Work on the current selection or used range
    If Selection.Cells.Count > 1 Then
        Set rng = Selection
    Else
        Set rng = ws.UsedRange
    End If

    Application.ScreenUpdating = False

    ' Step 1: Trim spaces and fix case
    For Each cell In rng
        If Not IsEmpty(cell) And Not IsNumeric(cell.Value) Then
            Dim original As String
            original = cell.Value

            ' Trim extra spaces (leading, trailing, and double spaces)
            Dim cleaned As String
            cleaned = Application.WorksheetFunction.Trim(cell.Value)
            If cleaned <> original Then
                trimCount = trimCount + 1
            End If

            ' Convert to Proper Case
            Dim proper As String
            proper = Application.WorksheetFunction.Proper(cleaned)
            If proper <> cleaned Then
                caseCount = caseCount + 1
            End If

            cell.Value = proper
        End If
    Next cell

    ' Step 2: Remove duplicate rows
    lastRow = ws.Cells(ws.Rows.Count, rng.Column).End(xlUp).Row
    lastCol = rng.Columns.Count
    Dim beforeRows As Long
    beforeRows = lastRow

    If lastRow > 1 Then
        ws.Range(ws.Cells(1, rng.Column), ws.Cells(lastRow, rng.Column + lastCol - 1)) _
            .RemoveDuplicates Columns:=1, Header:=xlYes
    End If

    Dim afterRows As Long
    afterRows = ws.Cells(ws.Rows.Count, rng.Column).End(xlUp).Row
    dupCount = beforeRows - afterRows

    Application.ScreenUpdating = True

    MsgBox "Cleanup Complete!" & vbCrLf & vbCrLf & _
           "Spaces trimmed: " & trimCount & " cells" & vbCrLf & _
           "Case fixed: " & caseCount & " cells" & vbCrLf & _
           "Duplicates removed: " & dupCount & " rows", _
           vbInformation, "Data Cleanup"
End Sub

I assign this to a keyboard shortcut (Ctrl+Shift+C) so my clients can run it without even opening the macro dialog. It turns a 15-minute manual cleanup into a 2-second operation.

3 Dynamic Named Ranges That Auto-Expand

If you use named ranges in your formulas, charts, or data validation dropdowns, you know the problem: every time you add new data, you have to manually update the range. Dynamic named ranges solve this permanently by using VBA to keep them in sync with your actual data.

How It Works

This macro scans your data and updates named ranges to match the current extent of each column. Run it on workbook open or attach it to a button.

Sub UpdateDynamicRanges()
    Dim ws As Worksheet
    Dim lastRow As Long
    Dim nm As Name

    Set ws = ThisWorkbook.Sheets("Data")
    lastRow = ws.Cells(ws.Rows.Count, "A").End(xlUp).Row

    ' Update or create named ranges
    On Error Resume Next

    ' Delete existing named ranges first
    ThisWorkbook.Names("ProductList").Delete
    ThisWorkbook.Names("SalesData").Delete
    ThisWorkbook.Names("DateRange").Delete
    On Error GoTo 0

    ' Create fresh dynamic ranges
    ThisWorkbook.Names.Add _
        Name:="ProductList", _
        RefersTo:=ws.Range("A2:A" & lastRow)

    ThisWorkbook.Names.Add _
        Name:="SalesData", _
        RefersTo:=ws.Range("A2:E" & lastRow)

    ThisWorkbook.Names.Add _
        Name:="DateRange", _
        RefersTo:=ws.Range("B2:B" & lastRow)

    ' Refresh any pivot tables that use these ranges
    Dim pt As PivotTable
    For Each pt In ws.PivotTables
        pt.RefreshTable
    Next pt

    Application.StatusBar = "Named ranges updated: " & lastRow - 1 & " rows"
End Sub

' Auto-run when workbook opens
Private Sub Workbook_Open()
    Call UpdateDynamicRanges
End Sub

This is especially valuable for workbooks with charts or pivot tables. Your charts always reflect the latest data without anyone having to adjust the source range manually.

4 Custom Right-Click Context Menu

Instead of making your team memorize macro names or hunt through the ribbon, you can add your most-used macros directly to the right-click context menu. It makes your VBA tools feel like native Excel features.

How It Works

The macro modifies the cell context menu (the CommandBar named "Cell") by adding custom entries. Put the setup code in Workbook_Open and the teardown in Workbook_BeforeClose.

Sub AddCustomContextMenu()
    Dim contextMenu As CommandBar
    Dim newButton As CommandBarButton

    ' Remove any existing custom items first
    Call RemoveCustomContextMenu

    Set contextMenu = Application.CommandBars("Cell")

    ' Add a separator
    contextMenu.Controls.Add(Type:=msoControlButton).BeginGroup = True

    ' Add "Clean Data" option
    Set newButton = contextMenu.Controls.Add(Type:=msoControlButton)
    With newButton
        .Caption = "Clean Selected Data"
        .FaceId = 270  ' Broom icon
        .OnAction = "CleanupData"
        .Tag = "CustomTool"
    End With

    ' Add "Export to PDF" option
    Set newButton = contextMenu.Controls.Add(Type:=msoControlButton)
    With newButton
        .Caption = "Export Sheet to PDF"
        .FaceId = 2170  ' Document icon
        .OnAction = "ExportActiveToPDF"
        .Tag = "CustomTool"
    End With

    ' Add "Send via Email" option
    Set newButton = contextMenu.Controls.Add(Type:=msoControlButton)
    With newButton
        .Caption = "Email This Sheet"
        .FaceId = 65   ' Mail icon
        .OnAction = "EmailActiveSheet"
        .Tag = "CustomTool"
    End With
End Sub

Sub RemoveCustomContextMenu()
    Dim contextMenu As CommandBar
    Dim ctrl As CommandBarControl

    Set contextMenu = Application.CommandBars("Cell")
    For Each ctrl In contextMenu.Controls
        If ctrl.Tag = "CustomTool" Then ctrl.Delete
    Next ctrl
End Sub

I use the .Tag property to mark custom entries so they can be cleanly removed when the workbook closes. This prevents your custom menu items from leaking into other workbooks.

Pro tip: Use .FaceId to add icons to your menu items. There are hundreds of built-in icons — search for "FaceId list" online to browse them all.

5 Batch PDF Export of Multiple Sheets

If you regularly need to export sheets as PDFs — monthly reports, invoices, department summaries — doing it one sheet at a time is painful. This macro exports every visible sheet (or a specific list of sheets) to individual PDF files in one click.

How It Works

The macro loops through each worksheet, exports it as a PDF to a folder you specify, and names each file using the sheet name and today's date.

Sub BatchExportToPDF()
    Dim ws As Worksheet
    Dim folderPath As String
    Dim fileName As String
    Dim exportCount As Long

    ' Let the user pick a destination folder
    With Application.FileDialog(msoFileDialogFolderPicker)
        .Title = "Select Export Folder"
        .Show
        If .SelectedItems.Count = 0 Then Exit Sub
        folderPath = .SelectedItems(1) & "\"
    End With

    Application.ScreenUpdating = False

    For Each ws In ThisWorkbook.Worksheets
        ' Skip hidden sheets
        If ws.Visible = xlSheetVisible Then
            ' Skip sheets with no data
            If Application.WorksheetFunction.CountA(ws.UsedRange) > 0 Then
                fileName = folderPath & ws.Name & "_" & _
                           Format(Date, "yyyy-mm-dd") & ".pdf"

                ws.ExportAsFixedFormat _
                    Type:=xlTypePDF, _
                    Filename:=fileName, _
                    Quality:=xlQualityStandard, _
                    IncludeDocProperties:=True, _
                    IgnorePrintAreas:=False, _
                    OpenAfterPublish:=False

                exportCount = exportCount + 1
            End If
        End If
    Next ws

    Application.ScreenUpdating = True

    MsgBox exportCount & " sheets exported as PDF to:" & vbCrLf & _
           folderPath, vbInformation, "Export Complete"

    ' Open the folder so the user can see the files
    Shell "explorer.exe " & folderPath, vbNormalFocus
End Sub

The macro also opens the destination folder in Windows Explorer when it finishes, so you can immediately see all the exported files. I have clients who use this to generate 20+ PDF reports at the end of every month.

6 Email Automation Directly from Excel

If your organization uses Outlook, you can send emails directly from Excel without ever leaving your spreadsheet. This is incredibly useful for sending personalized reports, invoice reminders, or status updates to a list of recipients.

How It Works

The macro reads a list of recipients and message details from a sheet, creates Outlook emails, attaches the current workbook (or a specific file), and either displays them for review or sends them automatically.

Sub SendEmailsFromList()
    Dim OutApp As Object
    Dim OutMail As Object
    Dim ws As Worksheet
    Dim lastRow As Long
    Dim i As Long
    Dim sentCount As Long

    Set ws = ThisWorkbook.Sheets("EmailList")
    lastRow = ws.Cells(ws.Rows.Count, "A").End(xlUp).Row

    ' Create Outlook instance
    Set OutApp = CreateObject("Outlook.Application")

    For i = 2 To lastRow ' Start from row 2 (skip header)
        Dim recipientEmail As String
        Dim recipientName As String
        Dim subject As String
        Dim status As String

        recipientEmail = ws.Cells(i, 1).Value  ' Column A: Email
        recipientName = ws.Cells(i, 2).Value   ' Column B: Name
        subject = ws.Cells(i, 3).Value         ' Column C: Subject
        status = ws.Cells(i, 4).Value          ' Column D: Status

        ' Skip if already sent or no email
        If status <> "Sent" And recipientEmail <> "" Then
            Set OutMail = OutApp.CreateItem(0)

            With OutMail
                .To = recipientEmail
                .Subject = subject
                .HTMLBody = "<p>Hi " & recipientName & ",</p>" & _
                            "<p>Please find the latest report attached. " & _
                            "Let me know if you have any questions.</p>" & _
                            "<p>Best regards</p>"
                .Attachments.Add ThisWorkbook.FullName
                .Display  ' Use .Send to send automatically
            End With

            ' Mark as sent
            ws.Cells(i, 4).Value = "Sent"
            ws.Cells(i, 5).Value = Now ' Column E: Timestamp
            sentCount = sentCount + 1

            Set OutMail = Nothing
        End If
    Next i

    Set OutApp = Nothing

    MsgBox sentCount & " emails created successfully.", _
           vbInformation, "Email Automation"
End Sub

I use .Display instead of .Send by default so you can review each email before it goes out. Once you are confident the template is right, switch to .Send for fully automated delivery. The status column prevents duplicate sends if you run the macro again.

7 Auto-Format Tables on Data Entry

Consistent formatting makes data easier to read and more professional. But manually applying alternating row colors, borders, and number formats every time someone adds a row is not a good use of anyone's time. This macro watches for new data entry and formats it instantly.

How It Works

Using the Worksheet_Change event, the macro detects when new data is entered and automatically applies your chosen formatting to the entire row.

' Place this in the Sheet module (e.g., Sheet1 code)
Private Sub Worksheet_Change(ByVal Target As Range)
    Dim dataRange As Range
    Dim lastCol As Long
    Dim row As Long

    ' Only trigger for cells in column A onwards, skip header
    If Target.Row < 2 Then Exit Sub
    If Target.Column > 10 Then Exit Sub

    Application.EnableEvents = False

    lastCol = Me.Cells(1, Me.Columns.Count).End(xlToLeft).Column
    row = Target.Row

    ' Set the entire row range
    Set dataRange = Me.Range(Me.Cells(row, 1), Me.Cells(row, lastCol))

    With dataRange
        ' Add borders
        .Borders.LineStyle = xlContinuous
        .Borders.Weight = xlThin
        .Borders.Color = RGB(200, 200, 200)

        ' Alternating row color
        If row Mod 2 = 0 Then
            .Interior.Color = RGB(245, 245, 245)
        Else
            .Interior.Color = RGB(255, 255, 255)
        End If

        ' Bold if it's a total or summary row
        If LCase(Me.Cells(row, 1).Value) = "total" Or _
           LCase(Me.Cells(row, 1).Value) = "subtotal" Then
            .Font.Bold = True
            .Interior.Color = RGB(255, 237, 204) ' Light orange
        End If
    End With

    ' Format currency columns (e.g., columns D and E)
    Me.Range(Me.Cells(row, 4), Me.Cells(row, 5)).NumberFormat = "$#,##0.00"

    ' Format date column (e.g., column B)
    Me.Cells(row, 2).NumberFormat = "mmm dd, yyyy"

    Application.EnableEvents = True
End Sub

The key detail here is Application.EnableEvents = False at the top. Without it, the macro would trigger itself when it changes cell values, creating an infinite loop. Always remember to set it back to True at the end.

8 Progress Bar for Long-Running Macros

When a macro takes more than a few seconds to run, users assume Excel has frozen and reach for the Task Manager. A simple progress bar keeps them informed and prevents panicked force-quits.

How It Works

This approach uses the Excel status bar as a lightweight progress indicator. No UserForm required — it works by updating Application.StatusBar with a visual bar made of block characters.

Sub ShowProgressBar(current As Long, total As Long, Optional task As String = "Processing")
    Dim pct As Double
    Dim barLength As Long
    Dim filledLength As Long
    Dim bar As String

    pct = current / total
    barLength = 30
    filledLength = Int(pct * barLength)

    ' Build the visual bar
    bar = String(filledLength, ChrW(9608)) & String(barLength - filledLength, ChrW(9617))

    Application.StatusBar = task & ": |" & bar & "| " & Format(pct, "0%") & _
                            " (" & current & " of " & total & ")"

    DoEvents ' Allow Excel to refresh the screen
End Sub

Sub ResetProgressBar()
    Application.StatusBar = False
End Sub

' Example: using the progress bar in a real macro
Sub ProcessLargeDataSet()
    Dim ws As Worksheet
    Dim lastRow As Long
    Dim i As Long

    Set ws = ActiveSheet
    lastRow = ws.Cells(ws.Rows.Count, "A").End(xlUp).Row

    Application.ScreenUpdating = False

    For i = 2 To lastRow
        ' --- Your processing logic here ---
        ws.Cells(i, 5).Value = ws.Cells(i, 2).Value * ws.Cells(i, 3).Value
        ws.Cells(i, 6).Value = Format(Now, "yyyy-mm-dd")

        ' Update progress every 100 rows (to avoid slowing things down)
        If i Mod 100 = 0 Or i = lastRow Then
            ShowProgressBar i - 1, lastRow - 1, "Calculating"
        End If
    Next i

    Application.ScreenUpdating = True
    ResetProgressBar

    MsgBox "Processed " & lastRow - 1 & " rows.", vbInformation, "Done"
End Sub

The trick is to update the progress bar every N rows instead of every single row. Updating the status bar on every iteration of a 100,000-row loop will make your macro slower, not faster. I typically update every 100 or 500 rows depending on the dataset size.

Pro tip: Always call ResetProgressBar at the end of your macro. If you forget, the status bar will be stuck showing your last progress message until the user restarts Excel.

9 Password-Protect Specific Sheet Ranges

Sometimes you need certain cells to be editable (data entry areas) while locking everything else (formulas, headers, structure). Excel's built-in protection dialog is clunky and easy to misconfigure. This macro handles it programmatically so you can apply protection consistently across multiple sheets.

How It Works

The macro unlocks specific ranges for editing while keeping the rest of the sheet protected. You can define different editable ranges for different user groups.

Sub ProtectSheetWithEditableRanges()
    Dim ws As Worksheet
    Dim pwd As String

    Set ws = ActiveSheet
    pwd = "YourPassword123"  ' Change this

    ' First, unprotect if already protected
    On Error Resume Next
    ws.Unprotect Password:=pwd
    On Error GoTo 0

    ' Lock all cells first
    ws.Cells.Locked = True
    ws.Cells.FormulaHidden = False

    ' Define editable ranges (unlock these)
    ' Data entry area: B2 to E100
    ws.Range("B2:E100").Locked = False

    ' Comments column
    ws.Range("G2:G100").Locked = False

    ' Status dropdown column
    ws.Range("F2:F100").Locked = False

    ' Highlight editable areas with a subtle background
    ws.Range("B2:E100").Interior.Color = RGB(255, 255, 240) ' Light yellow
    ws.Range("G2:G100").Interior.Color = RGB(255, 255, 240)
    ws.Range("F2:F100").Interior.Color = RGB(255, 255, 240)

    ' Hide formulas from the formula bar
    ws.Range("H:Z").FormulaHidden = True

    ' Apply protection with specific permissions
    ws.Protect Password:=pwd, _
        DrawingObjects:=True, _
        Contents:=True, _
        Scenarios:=True, _
        AllowFormattingCells:=False, _
        AllowFormattingColumns:=False, _
        AllowFormattingRows:=False, _
        AllowInsertingColumns:=False, _
        AllowInsertingRows:=True, _
        AllowDeletingColumns:=False, _
        AllowDeletingRows:=False, _
        AllowSorting:=True, _
        AllowFiltering:=True, _
        AllowUsingPivotTables:=True

    MsgBox "Sheet protected. Editable areas are highlighted in yellow.", _
           vbInformation, "Protection Applied"
End Sub

Sub UnprotectAllSheets()
    Dim ws As Worksheet
    Dim pwd As String
    pwd = "YourPassword123"

    For Each ws In ThisWorkbook.Worksheets
        On Error Resume Next
        ws.Unprotect Password:=pwd
        On Error GoTo 0
    Next ws

    MsgBox "All sheets unprotected.", vbInformation, "Protection Removed"
End Sub

Notice that the protection allows sorting and filtering even on locked cells. This is critical — users should be able to sort and filter their data without needing to unprotect the sheet. The AllowInsertingRows parameter is also set to True so users can add new rows for data entry.

10 Create a Personal Macro Library (Personal.xlsb)

All the macros above are great, but if they live in a single workbook, you can only use them when that workbook is open. The solution is Personal.xlsb — a hidden workbook that opens automatically every time you launch Excel. Any macro stored here is available in every workbook you open.

How It Works

First, you need to create the Personal Macro Workbook if it does not already exist. The easiest way is to record a dummy macro and select "Personal Macro Workbook" as the storage location. But you can also create it with VBA.

' Run this once to create Personal.xlsb if it doesn't exist
Sub CreatePersonalWorkbook()
    Dim personalPath As String
    personalPath = Application.StartupPath & "\PERSONAL.XLSB"

    If Dir(personalPath) = "" Then
        Dim wb As Workbook
        Set wb = Workbooks.Add
        Application.DisplayAlerts = False
        wb.SaveAs Filename:=personalPath, _
                  FileFormat:=xlOpenXMLWorkbookMacroEnabled
        Application.DisplayAlerts = True
        wb.Close
        MsgBox "Personal.xlsb created at:" & vbCrLf & personalPath, _
               vbInformation, "Setup Complete"
    Else
        MsgBox "Personal.xlsb already exists.", vbInformation, "Info"
    End If
End Sub

Once Personal.xlsb exists, open it (it is hidden by default — go to View > Unhide), press Alt + F11, and add your utility macros to a module. Here is a starter module I put in every Personal.xlsb.

' Personal Macro Library — available in ALL workbooks
' Store in Personal.xlsb > Module1

Sub QuickTimestamp()
    ' Insert current date and time in the active cell
    ActiveCell.Value = Now
    ActiveCell.NumberFormat = "mmm dd, yyyy h:mm AM/PM"
End Sub

Sub QuickFormatAsTable()
    ' Convert the current region to a formatted table
    Dim rng As Range
    Set rng = ActiveCell.CurrentRegion

    ' Apply table formatting
    ActiveSheet.ListObjects.Add(xlSrcRange, rng, , xlYes).Name = _
        "Table_" & Format(Now, "hhmmss")
End Sub

Sub QuickColumnStats()
    ' Show basic statistics for the selected column
    Dim rng As Range
    Set rng = Selection

    If rng.Rows.Count < 2 Then
        MsgBox "Select a range with data first.", vbExclamation
        Exit Sub
    End If

    Dim stats As String
    stats = "Column Statistics" & vbCrLf & vbCrLf
    stats = stats & "Count: " & Application.WorksheetFunction.Count(rng) & vbCrLf
    stats = stats & "Sum: " & Format(Application.WorksheetFunction.Sum(rng), "#,##0.00") & vbCrLf
    stats = stats & "Average: " & Format(Application.WorksheetFunction.Average(rng), "#,##0.00") & vbCrLf
    stats = stats & "Min: " & Application.WorksheetFunction.Min(rng) & vbCrLf
    stats = stats & "Max: " & Application.WorksheetFunction.Max(rng) & vbCrLf
    stats = stats & "Blanks: " & Application.WorksheetFunction.CountBlank(rng)

    MsgBox stats, vbInformation, "Quick Stats"
End Sub

Sub QuickRemoveBlanks()
    ' Delete blank rows in the selected range
    Dim rng As Range
    Dim i As Long

    Set rng = Selection
    Application.ScreenUpdating = False

    For i = rng.Rows.Count To 1 Step -1
        If Application.WorksheetFunction.CountA(rng.Rows(i)) = 0 Then
            rng.Rows(i).EntireRow.Delete
        End If
    Next i

    Application.ScreenUpdating = True
End Sub

The beauty of Personal.xlsb is that these utility macros are always just a keyboard shortcut away, no matter what workbook you are working in. I assign QuickTimestamp to Ctrl+Shift+T, QuickColumnStats to Ctrl+Shift+S, and QuickRemoveBlanks to Ctrl+Shift+B.

Getting Started

To use any of these VBA tricks:

1. Open your Excel workbook and press Alt + F11 to open the VBA editor
2. Insert a new module: Insert > Module
3. Paste the code and modify the sheet names, ranges, and parameters for your specific workbook
4. Run the macro with F5 or assign it to a button or keyboard shortcut
5. Save the workbook as .xlsm (macro-enabled workbook) to preserve your macros

Start with one or two tricks that solve your biggest pain points. Once you see how much time they save, you will want to automate everything.

Need Custom VBA Solutions?

If you want these macros tailored to your exact workflow — or if you have a more complex automation challenge — I would love to help. I have built hundreds of Excel VBA solutions for businesses on Upwork, from simple data cleanup scripts to full enterprise-grade reporting systems.

Get in touch for a free consultation, or hire me on Upwork to get started right away.