Wicked Smart Data
LearnInsightsAboutContact
Sign InLet's Build
LearnInsightsAboutContact
Sign InLet's Build
Wicked Smart Data

Intelligence, automation, and expert execution — plus an elite library of free knowledge. We turn complexity into competitive advantage.

Start a conversation

Platform

  • Learning Paths
  • Insights
  • RSS Feed

Company

  • About
  • Contact
  • Work With Us

Legal

  • Privacy Policy
  • Terms of Service

© 2026 Wicked Smart Data. All rights reserved.

Intelligence · Automation · Advantage

All Insights
Career Development

How to Build a Freelance Data Diagnostic Offer Using SQL and Power BI: Identifying Quick Wins in a Client's Existing Data Infrastructure and Turning a Free Audit into a Paid Engagement

A data diagnostic offer is one of the most powerful client acquisition tools in freelance consulting — but most practitioners wing it. This lesson shows you exactly how to design a repeatable audit using SQL and Power BI, structure your findings for maximum impact, and run the closing conversation that turns a diagnostic into a paid engagement.

🔥 Expert33 min readNov 19, 2026Updated Nov 19, 2026
How to Build a Freelance Data Diagnostic Offer Using SQL and Power BI: Identifying Quick Wins in a Client's Existing Data Infrastructure and Turning a Free Audit into a Paid Engagement
On this page
  • Introduction
  • Prerequisites
  • Designing the Diagnostic as a Productized Offer
  • Pricing the Diagnostic
  • The Pre-Audit Intake Process
  • Phase One: SQL-Based Infrastructure Analysis
  • 1. Database Schema Profiling
  • 2. Data Quality Profiling
  • 3. Query Performance Analysis
  • 4. Report and View Layer Analysis
  • Phase Two: Power BI Tenant and Report Audit
  • Assessing the Power BI Environment
  • Opening and Analyzing a Power BI Report
  • Synthesizing Findings: The Diagnostic Framework
  • Category 1: Critical Issues (Fix Within 30 Days)
  • Category 2: Performance Bottlenecks (Fix Within 60 Days)
  • Category 3: Structural Debt (Fix Within 90 Days)
  • Category 4: Opportunities (Prioritized Enhancements)
  • Building the Findings Deliverable in Power BI
  • Writing the Findings Report
  • The Debrief Call: Turning Findings into a Contract
  • Pricing the Follow-On Engagement
  • When the Free Audit Makes Sense (And When It Doesn't)
  • Hands-On Exercise
  • Common Mistakes and Troubleshooting
  • Scaling the Diagnostic Offer
  • Summary and Next Steps

How to Build a Freelance Data Diagnostic Offer Using SQL and Power BI: Identifying Quick Wins in a Client's Existing Data Infrastructure and Turning a Free Audit into a Paid Engagement

Introduction

You're on a discovery call with a mid-sized e-commerce company. Their head of operations is frustrated — the reports they're getting from their BI team take three days to arrive, the numbers never quite match between departments, and they suspect there are sales trends buried in their data that nobody's looking at. They don't know what they need. They just know something is broken. You have an hour and a half, access to their database credentials, and a laptop with SQL Server Management Studio and Power BI Desktop.

This is exactly the scenario a data diagnostic offer is built for. A diagnostic — sometimes called a data audit — is a structured, time-boxed analysis of a client's existing data infrastructure. The goal isn't to build anything new. It's to look at what they already have, identify where the gaps and inefficiencies are, and produce a clear prioritized list of improvements. Done well, it's one of the most powerful entry points in freelance data consulting. Done poorly, it's a lot of free work that goes nowhere.

By the end of this lesson, you'll know how to design a repeatable diagnostic offer, run it efficiently using SQL and Power BI, structure your findings into a deliverable that creates urgency, and use that deliverable to transition naturally into a paid engagement. This isn't just theory — we'll walk through real query patterns, actual Power BI techniques, and the exact conversational moves that turn an audit into a contract.

What you'll learn:

  • How to structure a data diagnostic offer as a productized service, including scope, timeline, and pricing
  • Which SQL queries and patterns to use for rapidly identifying data quality issues, performance bottlenecks, and reporting gaps
  • How to use Power BI to visualize audit findings in a way that communicates business impact to non-technical stakeholders
  • How to write a findings report that creates natural urgency for a follow-on engagement
  • How to run the closing conversation that turns diagnostic findings into a signed proposal

Prerequisites

This lesson assumes you're comfortable writing intermediate to advanced SQL — JOINs, window functions, aggregations, and subqueries. You should also know your way around Power BI Desktop well enough to build relationships between tables, write DAX measures, and configure report visuals. Familiarity with client-facing consulting work is helpful but not required; we'll cover the communication side explicitly. If you're newer to freelancing and still figuring out your foundational offer, Starting a Data Freelancing Business: Essential Tools, Pricing Strategies, and Landing Your First Clients is worth reading alongside this one.


Designing the Diagnostic as a Productized Offer

The first mistake most consultants make with audits is treating them as custom engagements. They scope each one differently, price each one differently, and deliver wildly different outputs. The result is that every diagnostic consumes a different amount of energy, and the offer becomes impossible to sell at scale.

The fix is to productize the diagnostic. That means defining a fixed scope, a fixed timeline, a fixed price, and a fixed output format. The specific findings will vary by client — that's unavoidable — but the structure of how you find them and how you present them stays consistent.

A well-designed data diagnostic offer has five components:

1. Intake scope definition. Before you touch a single query, you need to know what systems are in scope. Is this a single SQL Server database? A Snowflake warehouse plus a Power BI tenant? A pile of Excel files connected to a live database? The scope conversation determines what you're actually auditing. Keep this tight. A one-week diagnostic covers one primary data source and one primary reporting layer.

2. Time-boxed analysis. The analysis itself should take you two to three days of actual work. If it's taking longer, you've scoped it wrong or you're doing implementation work instead of diagnostic work. Discipline yourself to observe and document, not fix.

3. A findings report. This is your primary deliverable. It's not a 40-slide PowerPoint. It's a structured document — typically 10 to 15 pages — that covers what you found, what it means in business terms, and what it would take to fix it. We'll cover the structure in detail later.

4. A debrief call. A 60-minute call where you walk the client through the findings. This is where the sale happens.

5. A prioritized roadmap. A one-page appendix to the findings report that lists recommended actions in order of impact and effort. This becomes the foundation for your follow-on proposal.

Pricing the Diagnostic

Here's where most freelancers under-price themselves out of profitability. A proper data diagnostic — even when offered at a "discounted entry rate" — should not be free, and it should not be below $1,500 USD for a small business or $3,500 for a mid-market company. The free audit model has its place (we'll discuss it below), but free sends a signal that your time isn't valuable.

If you're offering the diagnostic as a loss leader to land a larger engagement, consider a nominal fee — $500 to $750 — with the understanding that the fee is credited against the larger project if they proceed. This creates genuine skin in the game on both sides.

Key insight

The diagnostic isn't just a sales tool — it's a service with real value. Even if the client doesn't proceed with the follow-on engagement, they should walk away with a genuinely useful roadmap. If you design it that way, the fee becomes easy to justify and the closing rate on follow-on work goes up, not down.

For a deeper dive into how to structure and price audit services as a client entry point, Packaging and Selling a Data Audit Service: How to Turn a One-Day Assessment into a High-Ticket Client Entry Point covers the sales mechanics in detail.


The Pre-Audit Intake Process

Before you write a single line of SQL, you need context. The pre-audit intake is a structured set of questions you send the client before you get access to anything. The goal is to understand what they think is broken, what decisions the data is supposed to support, and who currently uses it.

Send these questions as a simple Google Form or document attachment. Keep it to ten questions or fewer:

  1. What data systems are currently in use? (databases, cloud warehouses, SaaS tools with APIs, Excel files)
  2. What are the two or three most important business decisions that rely on data in your organization?
  3. What reports or dashboards currently exist, and who consumes them?
  4. What data-related problems are you most aware of right now? (slow reports, inconsistent numbers, missing data, etc.)
  5. Who owns the data infrastructure currently? (internal analyst, IT team, no one, external vendor)
  6. What does a "win" from this diagnostic look like to you in 30 days?

The answers to these questions tell you where to focus. If the client says "our reports are slow," you're going to spend time on query performance and table indexing. If they say "the numbers don't match," you're going to focus on data lineage and transformation logic. If they say "we don't know what's in our data," you're going to focus on profiling and cataloging.

Tip

Always ask the last question — what does a win look like? The answer tells you what the client values, which tells you how to frame your findings in business terms. A sales director wants to hear "we found a segment of customers who haven't reordered in 90 days and there's no trigger to contact them." A CFO wants to hear "your monthly close process is adding 18 hours of manual reconciliation that could be automated."


Phase One: SQL-Based Infrastructure Analysis

With access credentials in hand and intake responses reviewed, you're ready to start the diagnostic work. This phase is about understanding the shape of the data — its structure, quality, completeness, and query performance characteristics.

We'll work through the key diagnostic queries in four categories.

1. Database Schema Profiling

The first thing you want is a bird's-eye view of what's in the database. How many tables? How many rows? When was data last updated? This is especially important for clients who inherited their database from a previous team or vendor and don't have a clear picture of what's there.

For SQL Server:

SELECT 
    t.name AS table_name,
    s.name AS schema_name,
    p.rows AS row_count,
    SUM(a.total_pages) * 8 AS total_size_kb,
    MAX(si.last_user_update) AS last_data_change
FROM 
    sys.tables t
    INNER JOIN sys.schemas s ON t.schema_id = s.schema_id
    INNER JOIN sys.indexes i ON t.object_id = i.object_id
    INNER JOIN sys.partitions p ON i.object_id = p.object_id AND i.index_id = p.index_id
    INNER JOIN sys.allocation_units a ON p.partition_id = a.container_id
    LEFT JOIN sys.dm_db_index_usage_stats si 
        ON t.object_id = si.object_id AND i.index_id = si.index_id
        AND si.database_id = DB_ID()
WHERE 
    t.is_ms_shipped = 0
    AND i.object_id > 255
GROUP BY 
    t.name, s.name, p.rows
ORDER BY 
    p.rows DESC;

This query surfaces table names, row counts, storage size, and the last time data was actually modified. Run it in the first thirty minutes and you'll immediately spot anomalies: tables with millions of rows nobody mentioned, tables that haven't been updated in two years but are still referenced in reports, tables with zero rows that exist as schema artifacts.

2. Data Quality Profiling

Data quality issues are almost always present in real-world client environments. The question isn't whether they exist — it's which ones have business impact. You want to look at three things: nulls in important columns, duplicate records, and referential integrity violations.

Null analysis across key columns:

-- Replace 'orders' and your column list with the actual table under review
SELECT 
    'customer_id' AS column_name,
    COUNT(*) AS total_rows,
    SUM(CASE WHEN customer_id IS NULL THEN 1 ELSE 0 END) AS null_count,
    CAST(SUM(CASE WHEN customer_id IS NULL THEN 1 ELSE 0 END) * 100.0 / COUNT(*) AS DECIMAL(5,2)) AS null_pct
FROM orders
UNION ALL
SELECT 
    'order_date',
    COUNT(*),
    SUM(CASE WHEN order_date IS NULL THEN 1 ELSE 0 END),
    CAST(SUM(CASE WHEN order_date IS NULL THEN 1 ELSE 0 END) * 100.0 / COUNT(*) AS DECIMAL(5,2))
FROM orders
UNION ALL
SELECT 
    'revenue',
    COUNT(*),
    SUM(CASE WHEN revenue IS NULL THEN 1 ELSE 0 END),
    CAST(SUM(CASE WHEN revenue IS NULL THEN 1 ELSE 0 END) * 100.0 / COUNT(*) AS DECIMAL(5,2))
FROM orders;

Duplicate record detection:

-- Identify rows that share the same natural key — here, customer + order date + product
SELECT 
    customer_id,
    order_date,
    product_id,
    COUNT(*) AS duplicate_count
FROM orders
GROUP BY 
    customer_id,
    order_date,
    product_id
HAVING COUNT(*) > 1
ORDER BY duplicate_count DESC;

Referential integrity check (orphaned foreign keys):

-- Orders that reference customer_ids not in the customers table
SELECT 
    o.order_id,
    o.customer_id,
    o.order_date
FROM orders o
LEFT JOIN customers c ON o.customer_id = c.customer_id
WHERE c.customer_id IS NULL;

Warning

Be careful about running heavy profiling queries on production databases during business hours. Always ask the client whether the database is a live transactional system or a reporting replica before you start. If it's transactional, run your analysis during off-peak hours or ask for a read replica or snapshot.

3. Query Performance Analysis

Slow reports are one of the most common client complaints, and they're almost always traceable to one of three problems: missing indexes, poorly written queries that do full table scans, or reporting queries running directly against a transactional database with no separation of concerns.

For SQL Server, the Query Store and DMVs (Dynamic Management Views) are your best diagnostic tools:

-- Find the most expensive queries by average CPU time
SELECT TOP 20
    qs.total_elapsed_time / qs.execution_count AS avg_elapsed_time_ms,
    qs.total_logical_reads / qs.execution_count AS avg_logical_reads,
    qs.execution_count,
    qs.total_elapsed_time,
    SUBSTRING(qt.text, (qs.statement_start_offset / 2) + 1,
        ((CASE qs.statement_end_offset
            WHEN -1 THEN DATALENGTH(qt.text)
            ELSE qs.statement_end_offset
        END - qs.statement_start_offset) / 2) + 1) AS query_text
FROM 
    sys.dm_exec_query_stats qs
    CROSS APPLY sys.dm_exec_sql_text(qs.sql_handle) qt
ORDER BY 
    avg_elapsed_time_ms DESC;
-- Find tables with missing indexes (SQL Server specific)
SELECT TOP 20
    migs.avg_total_user_cost * migs.avg_user_impact * (migs.user_seeks + migs.user_scans) AS improvement_measure,
    mid.statement AS table_name,
    mid.equality_columns,
    mid.inequality_columns,
    mid.included_columns,
    migs.user_seeks,
    migs.user_scans,
    CAST(migs.avg_user_impact AS INT) AS avg_impact_pct
FROM 
    sys.dm_db_missing_index_group_stats migs
    INNER JOIN sys.dm_db_missing_index_groups mig ON migs.group_handle = mig.index_group_handle
    INNER JOIN sys.dm_db_missing_index_details mid ON mig.index_handle = mid.index_handle
ORDER BY 
    improvement_measure DESC;

The improvement_measure column is a composite score that SQL Server calculates based on how much an index would help. It's not a perfect metric, but anything above 100,000 is worth flagging in your findings.

4. Report and View Layer Analysis

Many clients have a tangle of views, stored procedures, and ad hoc queries that have accumulated over years. Part of your diagnostic is understanding what the reporting layer actually looks like — not just the base tables.

-- List all views and their definitions
SELECT 
    v.name AS view_name,
    s.name AS schema_name,
    m.definition AS view_definition,
    v.create_date,
    v.modify_date
FROM 
    sys.views v
    INNER JOIN sys.schemas s ON v.schema_id = s.schema_id
    INNER JOIN sys.sql_modules m ON v.object_id = m.object_id
ORDER BY 
    v.modify_date DESC;
-- Check for stored procedures that haven't been modified recently
-- (potential report logic that may be stale or unused)
SELECT 
    p.name AS procedure_name,
    p.create_date,
    p.modify_date,
    m.definition
FROM 
    sys.procedures p
    INNER JOIN sys.sql_modules m ON p.object_id = m.object_id
WHERE 
    p.modify_date < DATEADD(YEAR, -1, GETDATE())
ORDER BY 
    p.modify_date;

Stale views and procedures that haven't been touched in a year but are still referenced by reports are a major red flag. They often contain logic that no longer reflects the actual business process — and they're generating wrong numbers that nobody has caught yet.

Note

If the client is using PostgreSQL, MySQL, or BigQuery instead of SQL Server, the specific system tables and DMVs differ, but the diagnostic intent is identical. PostgreSQL uses pg_stat_user_tables, pg_stat_statements, and information_schema.columns for the same categories of analysis. BigQuery has INFORMATION_SCHEMA.JOBS for query performance and INFORMATION_SCHEMA.COLUMNS for schema profiling.


Phase Two: Power BI Tenant and Report Audit

If the client is using Power BI as their reporting layer, you have a second audit dimension: the Power BI environment itself. Many organizations accumulate a sprawling collection of reports, datasets, and workspaces with no governance. This is an enormous opportunity for a diagnostic.

Assessing the Power BI Environment

Before opening Power BI Desktop, start in the Power BI Service (powerbi.com) if the client gives you admin access. Navigate to the Admin Portal and look at:

Usage metrics: Under the Admin Portal, go to Usage Metrics to see which reports are actually being consumed. You'll often find that 80% of the reports in a tenant have zero or near-zero views in the last 30 days. This is immediately actionable — the organization is maintaining dead weight.

Dataset refresh history: Navigate to any workspace, open a dataset's settings, and check the refresh history. Failed refreshes that nobody is monitoring are extremely common and are silently corrupting the data people are trusting.

Workspaces without owners: Use the Power BI REST API or the Admin portal's workspace listing to identify workspaces where the original creator has left the company. These are technical debt ticking clocks.

Opening and Analyzing a Power BI Report

When you open a client's .pbix file for analysis, you're looking for several specific anti-patterns:

Direct Query vs. Import mode misuse: Open Power BI Desktop, then in the ribbon navigate to the Model view. Select any table and check the storage mode in the Properties pane. If tables that contain millions of rows are set to Import mode and the data is refreshing every 15 minutes, you're looking at a performance and cost problem. Conversely, if small dimension tables are using DirectQuery when Import mode would be faster and simpler, that's also worth flagging.

Calculated columns doing what measures should do: In the Data view, look at the field list for any calculated column that contains aggregation logic (SUM, AVERAGE, etc.). Calculated columns are computed row by row and stored in memory; measures are computed at query time against the current filter context. If someone has built Total Revenue = SUM(orders[revenue]) as a calculated column instead of a measure, it's consuming memory unnecessarily and will produce incorrect results when filtered.

Measure proliferation without documentation: Use the Model view to browse all measures. If you see 60+ measures with names like Revenue_v2, Revenue_Final, Revenue_FINAL_USE_THIS, and Revenue_new_fix — you've found a maintenance nightmare and a source of reporting inconsistency.

Relationships with wrong cardinality: In the Model view, examine every relationship line. A many-to-many relationship where a one-to-many should exist will cause measure values to inflate incorrectly, usually without any error message.

-- DAX to identify measures that may be duplicated or legacy
-- You can't query the model metadata directly in DAX, but you can use 
-- Tabular Editor (free version) to export all measures to a table.
-- In Tabular Editor: Tools > Scripting, then:

var output = new System.Text.StringBuilder();
foreach(var m in Model.AllMeasures) {
    output.AppendLine($"{m.Table.Name}\t{m.Name}\t{m.Expression}");
}
output.ToString()

This Tabular Editor script exports every measure name, its parent table, and its DAX expression to a text block you can paste into Excel and analyze for duplicates.

Tip

Power BI's built-in Performance Analyzer (View tab > Performance Analyzer > Start Recording, then interact with visuals) will show you the duration of each visual's DAX query. Any visual taking over 2,000ms to render is a candidate for optimization. Run this on the client's most-used report and screenshot the results — it's one of the most compelling visuals in your findings report because it shows a concrete number next to a problem.


Synthesizing Findings: The Diagnostic Framework

After two to three days of analysis, you'll have pages of notes, query results, and screenshots. The diagnostic framework is how you turn that raw material into a coherent narrative. It has four categories, presented in order of business impact:

Category 1: Critical Issues (Fix Within 30 Days)

These are problems that are actively producing wrong information or risk data loss. Failed dataset refreshes nobody is monitoring. Orphaned foreign keys causing joins to silently drop rows. Reports built on stale views. These go in your findings with explicit "here is the wrong number this is producing" evidence.

Category 2: Performance Bottlenecks (Fix Within 60 Days)

Slow queries, missing indexes, incorrectly modeled Power BI datasets. These don't produce wrong answers, but they waste time and erode trust in the reporting layer. Quantify these in time terms: "The slowest stored procedure in the reporting stack takes an average of 47 seconds per execution and runs 200 times per business day — that's 2.6 hours of compute time daily that could be reduced to under 10 minutes with index optimization."

Category 3: Structural Debt (Fix Within 90 Days)

Things that work now but will cause problems as the business grows: no documented data dictionary, no staging layer between transactional and reporting databases, Power BI datasets built directly on production SQL views, manual Excel handoffs in the middle of an otherwise automated pipeline.

Category 4: Opportunities (Prioritized Enhancements)

These are the quick wins — things that don't fix a problem so much as unlock new value. Customer segments nobody is currently reporting on. A revenue metric the business cares about that's one SQL query away from being automated. A Power BI report template that could serve three departments instead of one.

Key insight

Categories 1 and 4 are your most powerful persuasion tools. Category 1 creates urgency ("your data is wrong right now"). Category 4 creates excitement ("here's money you're leaving on the table"). Categories 2 and 3 justify the work. Structure your findings report to lead with something from each of the first two categories.


Building the Findings Deliverable in Power BI

Your findings report should have two components: a written document and a visual summary dashboard. The dashboard isn't the main deliverable — it's the leave-behind that the client can share internally without you in the room. This is strategic: when the client's stakeholders see a Power BI dashboard summarizing the audit findings, it reinforces your credibility and keeps your name in front of people who have budget authority.

Build the dashboard with four pages:

Page 1 — Executive Summary: A single-page overview with four KPI cards (number of critical issues found, estimated hours of manual work per week that could be eliminated, number of stale/unused reports identified, and one headline opportunity). Keep this simple. Executives make decisions based on this page.

Page 2 — Data Quality Scorecard: Use a matrix visual to show each table audited, with columns for null rate percentage, duplicate rate percentage, and referential integrity status. Use conditional formatting — green for clean, yellow for marginal, red for problematic. This is immediately scannable.

Page 3 — Performance Analysis: A bar chart of the top 10 slowest queries by average execution time. If you have baseline and post-optimization projections, add those as a comparison. Otherwise, label each bar with the query description and the table it hits.

Page 4 — Recommended Roadmap: A simple Gantt-style table (you can build this in Power BI with a matrix visual or a clustered bar chart) showing each recommended action, its category (critical/performance/structural/opportunity), estimated effort in days, and estimated impact rating (1-5). This becomes the conversation piece for the follow-on proposal.

The key to making this dashboard persuasive rather than merely informative is to consistently translate technical findings into business language. Don't say "17% null rate in the customer_email column." Say "17% of customer records have no email address, meaning your marketing automation campaigns are skipping those customers entirely." Same finding, completely different emotional response.


Writing the Findings Report

The written report is the professional artifact that positions you as an expert. It should follow this structure:

Section 1 — Executive Summary (1 page): Three paragraphs. What you looked at. What you found at a headline level. What you recommend, in priority order. No technical language on this page.

Section 2 — Methodology (half a page): What you analyzed, over what time period, with what access. This section builds trust and answers the "how do you know?" question before it gets asked.

Section 3 — Critical Findings (3-5 pages): Each finding gets its own subsection with: a plain-language title ("Customer Records Missing Email Address"), a technical description of what you found and how you found it, the business impact in concrete terms, and a preliminary recommendation. Include screenshots of query results as evidence.

Section 4 — Performance Analysis (2-3 pages): The query performance findings with the actual numbers from the DMV queries you ran. Include the missing index recommendations with the SQL to create them — this is valuable enough that clients will often pay just for this section's implementation.

Section 5 — Structural Observations (1-2 pages): The technical debt inventory. Keep this factual and non-judgmental. You're not blaming anyone for the state of the system; you're documenting what you found.

Section 6 — Prioritized Roadmap (1 page): The table of recommended actions with effort and impact ratings. This is the most important page in the document for selling the follow-on work.

Section 7 — Next Steps (half a page): What you recommend as the immediate next engagement, what it would include, and a rough scope. Don't put a price in the written report — that's for the debrief conversation.

Warning

Resist the urge to include everything you found. A findings report stuffed with 40 observations reads as disorganized and overwhelming. Curate ruthlessly. Your job is not to demonstrate how much you found — it's to communicate the highest-impact issues with enough clarity that the client knows exactly what to do next. Ten focused findings beat forty scattered ones every time.


The Debrief Call: Turning Findings into a Contract

The debrief call is the most important hour of the entire diagnostic process. Everything you've done up to this point is preparation for this conversation. Here's how to structure it.

Minutes 0–5: Frame the conversation. Start by confirming who's in the room (ideally, you want both a technical person and a decision-maker) and setting the agenda: "I'll walk you through what I found, we'll discuss the priority areas, and then I want to hear from you about which of these resonates most with where you're trying to go."

Minutes 5–20: Walk through the dashboard. Share your screen and open the Power BI findings dashboard. Start with the executive summary page. Let the numbers land before you explain them. When you show the data quality scorecard with red cells, pause. Let them react. The silence is productive — it's letting the finding register emotionally.

Minutes 20–40: Deep dive on the critical findings. For each critical issue, present the finding, then immediately translate it to business impact, then pause and ask a question: "Does this match what you've been experiencing?" or "Who on your team is currently responsible for this?" These questions serve two purposes: they confirm your findings are accurate, and they help you understand the internal politics around fixing the problem.

Minutes 40–50: Discuss the roadmap. Show the prioritized roadmap page and ask: "If we could only fix three of these things in the next 60 days, which three would have the biggest impact on your team?" Let them tell you what they care about. This is gold — you're letting the client build your follow-on project scope for you.

Minutes 50–60: The transition. This is where you make the move from audit to proposal. It sounds like this: "Based on what you've told me about priorities, I'd put together a proposal for [scope they've described]. From what I've seen in the diagnostic, I'd estimate this is [X weeks] of work. I'll have a proposal to you by [specific date, two to three days out]. Does that work?"

Key insight

Don't ask "are you interested in moving forward?" That's a yes/no question that invites hesitation. Instead, assume the engagement and ask a logistics question: "I'll have a proposal to you by Thursday — does Thursday work?" You're not being pushy; you're being professional and creating momentum. If they're not ready, they'll tell you.

For more on how to write the proposal itself after this call, Writing a Winning Data Freelance Proposal: Structure, Messaging, and Common Mistakes to Avoid covers exactly what to include and how to frame the scope you just agreed on together.


Pricing the Follow-On Engagement

The diagnostic has done something powerful for your pricing position: it's given the client's problems a price tag before you present your rate. When you show them that slow queries are consuming 2.6 hours of compute time daily, or that 17% of their customer records are invisible to their marketing system, you've anchored the conversation around cost of the problem rather than cost of the solution.

This is the foundation of value-based pricing, and it changes the dynamics of the follow-on proposal entirely. Instead of the client asking "why does it cost $12,000 to fix these queries?", they're thinking "2.6 hours of compute time daily, 250 working days a year, our infrastructure costs $X per hour... actually this pays for itself pretty fast."

Structure the follow-on engagement in phases, not as one large block. This reduces the client's perceived risk and gives them a natural place to start. A typical follow-on structure after a diagnostic might look like:

  • Phase 1 — Critical Fixes (2–3 weeks): Fix the data quality issues and failed refresh monitoring. Deliverable: clean data, automated alerting.
  • Phase 2 — Performance Optimization (3–4 weeks): Implement the missing indexes, refactor the heaviest stored procedures, restructure the Power BI dataset. Deliverable: benchmarked before/after performance report.
  • Phase 3 — Reporting Layer (4–6 weeks): Rebuild the core reporting dashboard on a clean data model, retire the stale reports, create a simple data dictionary. Deliverable: production Power BI workspace.

Each phase is separately scoped and separately priced. The client can approve one phase at a time. In practice, most clients approve all three in the first conversation — the diagnostic has already created trust and demonstrated your competence.

For detailed guidance on structuring this kind of tiered engagement at a price that reflects value, Pricing Data Projects: Hourly vs Fixed vs Value-Based - A Complete Guide for Data Professionals goes deep on the mechanics.


When the Free Audit Makes Sense (And When It Doesn't)

There's a persistent debate in freelance circles about whether to offer a completely free diagnostic as a lead generation mechanism. The honest answer: it depends on your situation and the specific client.

The free audit is defensible in two scenarios:

You're early in your freelance practice and need portfolio work. If you have strong SQL and Power BI skills but no client-facing diagnostic experience, one or two free audits for small businesses will give you findings reports to reference, real-world client experience running the debrief call, and testimonials to use in your outreach. Treat the free audit as an investment in your professional education, but cap yourself at two. After that, start charging.

The potential follow-on engagement is large enough to justify it. If a client is considering a $50,000 data infrastructure overhaul and they want to see your work before committing, a free or nominal-fee diagnostic is a reasonable positioning move. You're essentially spending two to three days of time to compete for a substantial contract.

The free audit is not defensible in two scenarios:

The client has no defined follow-on intent. If a prospect wants a free audit "to see what's there" with no clear conversation about what happens after, they're using your diagnostic for internal purposes without any intention of paying you. This happens more often than you'd think. Qualifying Freelance Data Clients Before You Pitch: Red Flags, Budget Signals, and the Discovery Call Framework will help you spot these situations early.

You're already established and in demand. If you have a waitlist of clients and a strong conversion rate on paid diagnostics, offering free audits is simply leaving money on the table. Established consultants should not be offering free diagnostics — it undercuts your positioning as a premium service provider.


Hands-On Exercise

This exercise is designed to replicate the diagnostic workflow as closely as possible using publicly available data. You'll need SQL Server or PostgreSQL installed locally (or access to a cloud database), and Power BI Desktop.

Step 1: Set up the sample database. Download the AdventureWorks sample database for SQL Server (available from Microsoft's GitHub repository) or the Northwind database for PostgreSQL. These are realistic business databases with the kind of structural issues you'd find in real client environments.

Step 2: Run the schema profiling query. Execute the schema profiling query from the SQL analysis section against your sample database. Document: how many tables exist, which are the five largest by row count, and which tables haven't been modified recently.

Step 3: Run data quality profiling. Choose three tables from AdventureWorks or Northwind that you'd expect to be central to business reporting (order headers, customer records, product records). Run the null analysis and duplicate detection queries against each. Document the null rates for each key column.

Step 4: Run the missing index query. Run some intentionally expensive queries against the database first (full table scans on large tables without WHERE clause filtering), then execute the missing index DMV query. Note what indexes SQL Server recommends and what the improvement measure scores are.

Step 5: Build a mini findings dashboard in Power BI. Import the results of your profiling queries into Power BI (you can export them to CSV from SSMS and import to Power BI Desktop). Build a two-page report: one page with KPI cards showing total tables audited, tables with null rates above 10%, and tables with duplicates detected; one page with a matrix showing each table's null rate and duplicate rate.

Step 6: Write a one-page executive summary. Based on what you found in steps 2–4, write a plain-language executive summary as if you were delivering it to a non-technical business owner. Focus on what the issues mean for the business, not what they mean technically.

This exercise typically takes four to six hours. When you've completed it, you have a template diagnostic workflow you can replicate on a real client's data.


Common Mistakes and Troubleshooting

Mistake 1: Going too deep on fixes during the diagnostic. The diagnostic is for finding problems, not fixing them. The moment you start actually implementing index changes or rewriting Power BI measures, you've slipped out of diagnostic mode and into implementation mode — without a contract covering that work. Document what you find; fix it in the follow-on engagement.

Mistake 2: Presenting to a room with no decision-makers. If the debrief call only includes technical staff and no one with budget authority, your conversion rate will tank. The technical team may love your findings and want to proceed, but they can't approve spend. Always confirm before the call that at least one person with budget authority will attend. If they won't, ask if you can schedule a separate 20-minute executive briefing.

Mistake 3: Technical jargon in the findings report. You will lose your audience — and your sale — the moment the report becomes unreadable to a business owner. Every finding should have two sentences: one technical (for credibility) and one in plain English (for comprehension). "The SalesOrderHeader table has no index on the OrderDate column, causing the monthly revenue report query to perform a full table scan of 1.2 million rows. In plain terms: this is why the monthly revenue report takes three minutes to open."

Mistake 4: Under-scoping the access you need. If the client only gives you read access to two of the five databases their reporting stack touches, your diagnostic will be incomplete — and you'll look uninformed when they ask why you didn't find certain things. Before the diagnostic begins, explicitly confirm what systems are in scope and what access level you need to analyze each one.

Mistake 5: Failing to follow up after the debrief. This one is surprisingly common. The debrief goes well, the client is engaged, you say you'll send a proposal by Thursday — and then life gets busy and you send it the following Tuesday. This is a conversion killer. Set a calendar reminder the moment the call ends. The proposal lands within 48 hours of the debrief or the momentum dissipates.

Warning

Be careful about scope creep within the diagnostic itself. Clients who see you actively looking at their data will sometimes ask you to "just take a quick look at this other thing" or "while you're in there, can you tell us why this report is wrong?" Every one of these requests is out-of-scope work. Acknowledge the question, note it in your findings document, and tell them "that's a great question for the follow-on scope." Don't answer it for free. For more on protecting your scope, Client Management: Scope, Communication, and Revisions for Data Freelancers covers exactly how to handle these moments.


Scaling the Diagnostic Offer

Once you've run three or four diagnostics and have a consistent findings report template, the diagnostic becomes the highest-leverage entry point in your entire freelance practice. It's faster to sell than a custom project (because the scope is fixed), it's faster to deliver (because you've built the SQL scripts and Power BI template), and it converts to paid follow-on work at a dramatically higher rate than cold proposals.

At this stage, you can consider two scaling moves:

Package the diagnostic into a tiered service menu. A Bronze diagnostic might cover a single database and produce a one-page findings summary. Silver covers a full data stack (database plus reporting layer) and delivers the full findings report and dashboard. Gold adds two stakeholder interviews, a live workshop session, and an extended roadmap. Each tier has a fixed price. This kind of structure is covered in depth in Building a Data Freelance Service Tier Menu: How to Structure Bronze, Silver, and Gold Packages That Upsell Clients Without Hourly Negotiation.

Develop a proprietary diagnostic methodology. When you've run enough diagnostics to have a pattern — consistent categories, consistent query types, consistent findings — you can formalize that process into a named methodology. "The DataClear Assessment" or "The Infrastructure Clarity Audit." A named methodology commands premium pricing and differentiates you from every other consultant who offers a "data audit." Building and Monetizing a Freelance Data Methodology: How to Package Your Problem-Solving Process into a Proprietary Framework That Commands Premium Rates walks through exactly how to do this.


Summary and Next Steps

The data diagnostic offer is one of the most effective client acquisition tools available to a skilled SQL and Power BI freelancer — but only when it's designed and executed with intention. The key principles:

  1. Productize the diagnostic. Fixed scope, fixed timeline, fixed deliverables. Consistency is what makes it scalable.

  2. Use SQL systematically. Schema profiling, data quality analysis, query performance diagnostics, and report layer analysis are your four categories. Run them in order. Document everything.

  3. Build a findings deliverable that speaks to business people. Every technical finding gets a business impact translation. The Power BI dashboard is your leave-behind, not your main event.

  4. Run the debrief call with intention. Lead with the dashboard, pause on the critical findings, let the client build the follow-on scope, then assume the engagement and ask a logistics question.

  5. Price the follow-on work in phases. Each phase is independently valuable and independently approved. This reduces friction and keeps the conversation moving.

Your immediate next steps:

  • Download AdventureWorks or Northwind and run through the hands-on exercise to build your diagnostic muscle memory
  • Create a findings report template in Word or Google Docs with the seven sections defined in this lesson
  • Build a Power BI template file with the four dashboard pages pre-built, ready to populate with client-specific data
  • Define your diagnostic pricing: what do you charge for a Bronze, Silver, and Gold tier?
  • Identify two or three contacts in your network who might be open to a diagnostic conversation and reach out

The diagnostic offer is a force multiplier for everything else in your freelance practice. It creates trust quickly, positions you as a strategic advisor rather than a task executor, and generates a natural, low-friction path to larger paid engagements. Run it well, and it becomes the engine of your entire client pipeline.

Work With Us

From insight to implementation

Reading is the start. When you're ready to build the data, automation, or AI systems behind it, our team turns strategy into shipped results.

Let's Build

Freelancing with Data Skills

Previous

How to Build a Freelance Data Automation Service Using Excel Macros and Power Query: Packaging Repetitive Client Workflows into a Recurring Monthly Offer

Related Insights

Career DevelopmentPractitioner

How to Write a Data Analyst Resume With No Professional Experience: Structuring Projects, Skills, and Education to Pass Recruiter Screening in Under Six Seconds

23 min
Career DevelopmentPractitioner

How to Build a Freelance Data Automation Service Using Excel Macros and Power Query: Packaging Repetitive Client Workflows into a Recurring Monthly Offer

24 min
Career DevelopmentFoundation

How to Find and Use Real-World Datasets to Build a Data Portfolio When You Have No Work Experience

17 min

On this page

  • Introduction
  • Prerequisites
  • Designing the Diagnostic as a Productized Offer
  • Pricing the Diagnostic
  • The Pre-Audit Intake Process
  • Phase One: SQL-Based Infrastructure Analysis
  • 1. Database Schema Profiling
  • 2. Data Quality Profiling
  • 3. Query Performance Analysis
  • 4. Report and View Layer Analysis
  • Phase Two: Power BI Tenant and Report Audit
  • Assessing the Power BI Environment
  • Opening and Analyzing a Power BI Report
  • Synthesizing Findings: The Diagnostic Framework
  • Category 1: Critical Issues (Fix Within 30 Days)
  • Category 2: Performance Bottlenecks (Fix Within 60 Days)
  • Category 3: Structural Debt (Fix Within 90 Days)
  • Category 4: Opportunities (Prioritized Enhancements)
  • Building the Findings Deliverable in Power BI
  • Writing the Findings Report
  • The Debrief Call: Turning Findings into a Contract
  • Pricing the Follow-On Engagement
  • When the Free Audit Makes Sense (And When It Doesn't)
  • Hands-On Exercise
  • Common Mistakes and Troubleshooting
  • Scaling the Diagnostic Offer
  • Summary and Next Steps