Interview Coding Take-Homes: Part 3#

15 December 2025

UCLA Health - Population Analysis#

This take-home was about the data ingestion and cleaning for the UCLA Health population project. The goal was to take messy JSON from an API and turn it into a clean CSV, so the analysis and visualization could focus on the real questions without getting bogged down in data cleanup.

Goals#

Produce a CSV with a fixed header order and stable types.
Keep each transformation small and unit-testable.
Fail fast on missing required fields and log useful diagnostics.

Why this approach#

Even though the dataset was small and straightforward, it had all the typical real-world issues: keys with spaces, inconsistent casing, and numbers as strings. Instead of using heavy tools, I focused on keeping things clear, with predictable output and a simple flow I could easily follow.

Repository#

The implementation is in the population-analysis repo under the Analysis/ directory. See the source and examples at:

population-analysis (Analysis)

Process overview#

Load JSON from the API or from the cached sample used in tests.
Rename and normalize keys so everything aligns with the internal schema.
Coerce types (strings -> ints/dates) and fail if required data is missing.
Emit two CSVs: one raw mapping for auditing and one cleaned file for analysis.

Key implementation details#

Handling messy JSON keys#

The prompt demanded a tight mapping between API fields and output columns. Because the API returns keys with spaces and wobbly casing, the data model leans on [JsonPropertyName] attributes to translate them into clean C# properties:

PopulationEntry.cs#

    [JsonPropertyName("ID State")]
    public string IdState { get; set; } = "";
    public string State { get; set; } = "";
    [JsonPropertyName("ID Year")]
    public int IdYear { get; set; }
    public string Year { get; set; } = "";
    public int Population { get; set; }
    [JsonPropertyName("Slug State")]
    public string SlugState { get; set; } = "";

This keeps the mapping explicit and makes it obvious which API field feeds each column.

Fetching and caching the data#

The application calls the public census API, but I do not re-fetch on every test run. Instead the client caches the payload locally so the API stays quiet while I iterate:

Api.cs#

    var data = await GetFromCache();
    if (data != null) return data;

    var httpClient = httpClientFactory.CreateClient(nameof(Api));
    httpClient.BaseAddress = new Uri("https://datausa.io/");

On a fresh pull, the JSON hits disk before deserialization. That keeps the workflow testable and reinforces a clean separation of concerns:

Api.cs#

    try
    {
        json.Seek(0, SeekOrigin.Begin);
        await json.CopyToAsync(cacheDestination);
        await cacheDestination.FlushAsync();
        log.LogDebug("API data written to cache.");
    }
    catch
    {
        log.LogDebug("Failed to write API JSON result cache.");
    }
    json.Seek(0, SeekOrigin.Begin);
    data = await JsonSerializer.DeserializeAsync<Result>(json);

Example input (trimmed)#

This is an example of the API shape-keys with spaces, mixed casing, and numeric types that arrive as JSON numbers.

sample_input.json#

{
    "data": [
        { "ID State": "04000US01", "State": "Alabama", "Year": 2023, "Population": 5054253, "Slug State": "alabama" },
        { "ID State": "04000US02", "State": "Alaska", "Year": 2023, "Population": 733971, "Slug State": "alaska" }
    ]
}

The ingest pipeline renames those columns to id, state, slug, etc., and asserts that the types stay stable before writing the normalized CSV.

Normalized CSV (representative rows)#

The cleaned CSV fixes the header order and uses explicit types. Representative rows:

id,state,slug,year,population
04000US01,Alabama,alabama,2023,5054253
04000US02,Alaska,alaska,2023,733971

Notes on implementation#

API keys such as "ID State" and "Slug State" map to canonical names (id, slug) so downstream code never reasons about the raw schema.
Validation is blunt by design: missing required fields fail the run; weird values get logged for inspection instead of disappearing quietly.
Every time a new API field appeared, I did the same ritual: dump a single response to disk, diff it against the schema, and verify the mapping by regenerating the CSV. That quick loop kept regressions visible without a ton of ceremony.

Testing and verification#

Testing the pipeline#

Before trusting the CSV, I walk through the same routine I use on most take-homes: run the automated suite, then spot-check the binary output.

$ cd population-analysis
$ dotnet test

The tests live in population-analysis/Test and use xUnit + Moq. They verify that the ingestion pipeline does what I expect even when the API or filesystem behaves badly.

What the tests cover#

Test/AnalysisApi.cs drives the API client through both code paths. It ensures cached payloads short-circuit HTTP calls, verifies that cache files are written before parsing, and checks that failures log meaningful errors.
Test/AnalysisReport.cs exercises the aggregation layer. It confirms that populations group by state/year, headers stay deterministic, sorted tables behave, and the factor column lines up with each year.
Test/AnalysisReport.cs also reflection-loads the Report helpers so I can assert on the tables without spinning up the CLI.

Manual sanity checks#

Automated tests catch regressions, but I still run a quick end-to-end pass to see the CSV with my own eyes:

$ cd population-analysis
$ dotnet run --project Analysis/Analysis.csproj
Enter a path to write the CSV file to:

I point it at population.csv, inspect the generated CSV/raw pair, and spot-check a few rows against the original JSON. When a slug or population looks wrong, I can walk back through the normalization rules immediately.

Running with Docker#

If you prefer not to set up .NET locally, the application also runs in a Docker container. The image is multi-arch and supports both AMD64 and ARM64, so it should work on most systems.

Pull and run it like this:

$ docker run \
    -u $(id -u):$(id -g) \
    -v /path/to/output/directory:/csv_destination \
    --rm -it \
    aholmes0/population-analysis:latest

This mounts a local directory to /csv_destination inside the container, where the CSV files get written. The -u flag runs as your user ID to avoid permission issues with the output files.

Tradeoffs#

The pipeline favors clarity and observability over extreme throughput. It assumes the dataset fits on one machine without drama.
Formal schema enforcement (JSON Schema, etc.) would help for larger teams, but I skipped it here to keep iteration fast.

Analysis and findings#

With the cleaned CSV ready, I shifted into exploration mode. The dataset spans multiple years across every U.S. state and territory, so it is a natural fit for trend comparisons. The headline question people kept asking was: Are Californians moving to Texas? Rather than lean on anecdotes, I ran the numbers.

Key steps:

Compute year-over-year population changes per state.
Normalize growth rates with z-scores and compare peers head-to-head.
Flag periods where migration signals diverged.
Plot each view so the story is obvious without reading code.

Result: both California and Texas keep growing, and their growth curves tend to move in tandem. That implies broader economic or demographic drivers rather than a one-way California -> Texas pipeline.

Testing the idea#

I do not accept charts at face value, so I poked at the data from a few angles:

Cross-check the raw counts. Before normalizing, I spot-checked California and Texas populations against the Census CSV to ensure the ingest layer did not mangle digits. Having the raw CSV beside the formatted one made this painless.
Validate the story with multiple transforms. The z-score plot highlights divergences, but I also built the rank-change visualization to confirm the same periods popped out. If two independent views disagree, the notebook gets deleted.
Interrogate the edges. Whenever a state’s growth looked extreme, I tracked it back to the underlying rows to see if the spike came from a real trend or a data glitch. That habit kept the write-up grounded in facts, not vibes.

Output and visualization#

The cleaned population data:

population.csv (first 10 rows)#

"State Name","2013","2014","2015","2016","2017","2018","2019","2020","2021","2022","2022 Factors"
"Alabama","4799277","4817678 (0.38%)","4830620 (0.27%)","4841164 (0.22%)","4850771 (0.20%)","4864680 (0.29%)","4876250 (0.24%)","4893186 (0.35%)","4997675 (2.14%)","5028092 (0.61%)","2;2;97;12959"
"Alaska","720316","728300 (1.11%)","733375 (0.70%)","736855 (0.47%)","738565 (0.23%)","738516 (-0.01%)","737068 (-0.20%)","736990 (-0.01%)","735951 (-0.14%)","734821 (-0.15%)","389;1889"
"Arizona","6479703","6561516 (1.26%)","6641928 (1.23%)","6728577 (1.30%)","6809946 (1.21%)","6946685 (2.01%)","7050299 (1.49%)","7174064 (1.76%)","7079203 (-1.32%)","7172282 (1.31%)","2;13;311;887"
"Arkansas","2933369","2947036 (0.47%)","2958208 (0.38%)","2968472 (0.35%)","2977944 (0.32%)","2990671 (0.43%)","2999370 (0.29%)","3011873 (0.42%)","3006309 (-0.18%)","3018669 (0.41%)","3;47;79;271"
"California","37659181","38066920 (1.08%)","38421464 (0.93%)","38654206 (0.61%)","38982847 (0.85%)","39148760 (0.43%)","39283497 (0.34%)","39346023 (0.16%)","39455353 (0.28%)","39356104 (-0.25%)","2;2;2;53;92821"
"Colorado","5119329","5197580 (1.53%)","5278906 (1.56%)","5359295 (1.52%)","5436519 (1.44%)","5531141 (1.74%)","5610349 (1.43%)","5684926 (1.33%)","5723176 (0.67%)","5770790 (0.83%)","2;5;59;9781"
"Connecticut","3583561","3592053 (0.24%)","3593222 (0.03%)","3588570 (-0.13%)","3594478 (0.16%)","3581504 (-0.36%)","3575074 (-0.18%)","3570549 (-0.13%)","3605330 (0.97%)","3611317 (0.17%)","3611317"
"Delaware","908446","917060 (0.95%)","926454 (1.02%)","934695 (0.89%)","943732 (0.97%)","949495 (0.61%)","957248 (0.82%)","967679 (1.09%)","981892 (1.47%)","993635 (1.20%)","5;37;41;131"
"District of Columbia","619371","633736 (2.32%)","647484 (2.17%)","659009 (1.78%)","672391 (2.03%)","684498 (1.80%)","692683 (1.20%)","701974 (1.34%)","683154 (-2.68%)","670587 (-1.84%)","3;223529"

Key analysis code blocks and observations:

Helper Functions for Analysis#

Before diving into visualizations, I defined helper classes and functions to handle the data transformations consistently across plots.

FillData class and zscore helper functions#

class FillData(NamedTuple):
    year1: str
    year2: str
    zscore1: float
    zscore2: float
    change1: float
    change2: float
    middle_x: float
    middle_y: float

def zscore(change):
    """Calculate the zscore of a change."""
    return (change - change.mean()) / change.std()

def get_fill_data(year_idx, change1, change2, zscore1, zscore2):
    """Get data needed for plot_fill(...) and fill(...)"""
    year1, year2 = change1.index[i], change1.index[i + 1]
    zscore_change1 = zscore1.iloc[i + 1] - zscore1.iloc[i]
    zscore_change2 = zscore2.iloc[i + 1] - zscore2.iloc[i]
    middle_x = (year_idx + year_idx + 1) / 2
    middle_y = (zscore1.iloc[i] + zscore1.iloc[i + 1]) / 2
    return FillData(year1, year2, zscore1, zscore2, zscore_change1, zscore_change2, middle_x, middle_y)

def plot_fill(change1: float, change2: float, fill_data: FillData, color1: str = '#1f77b4', color2: str = '#ff7f0e'):
    """Draws the plot for fill data between fill_data.year1 and fill_data.year2"""
    if change1 < 0 and change2 < 0:  # Both changes are declining
        if abs(change1) > abs(change2):  # First change declines more
            fill(fill_data, color1, ('\u2193', color1), ('\u2193', color2), 0.5)
        else:  # Second change declines more
            fill(fill_data, color2, ('\u2193', color1), ('\u2193', color2), 0.5)
    elif change1 > 0 and change2 > 0:  # Both changes are growing
        if abs(change1) < abs(change2):  # Change1 grows less
            fill(fill_data, color2, ('\u2191', color1), ('\u2191', color2), 0.1)
        else:  # Change2 grows less
            fill(fill_data, color2, ('\u2191', color1), ('\u2191', color2), 0.1)
    else:  # One is growing, the other is declining
        change1_arrow = '\u2193' if change1 < 0 else '\u2191'
        change2_arrow = '\u2193' if change2 < 0 else '\u2191'
        if change1 < change2:  # Change1 declines more or grows less
            fill(fill_data, color1, (change1_arrow, color1), (change2_arrow, color2), 0.5)
        else:  # Change 2 declines more or grows less
            fill(fill_data, color2, (change1_arrow, color1), (change2_arrow, color2), 0.5)

def fill(
    fill_data: FillData,
    color: str,
    arrow_left: tuple[str, str],
    arrow_right: tuple[str, str],
    alpha: float
):
    """Fills the space between fill_data.year1 and fill_data.year2"""
    plt.fill_between([fill_data.year1, fill_data.year2],
                     fill_data.zscore1.iloc[i:i + 2], fill_data.zscore2.iloc[i:i + 2],
                     facecolor=color, alpha=alpha)
    middle_x = fill_data.middle_x
    middle_y = fill_data.middle_y
    plt.gca().add_patch(FancyBboxPatch((middle_x - 0.10, middle_y - 0.05), 0.1, 0.1,
                                        boxstyle="round,pad=0.01", facecolor='white', edgecolor='none', zorder=2))
    plt.gca().add_patch(FancyBboxPatch((middle_x + 0.0, middle_y - 0.05), 0.1, 0.1,
                                        boxstyle="round,pad=0.01", facecolor='white', edgecolor='none', zorder=2))
    plt.annotate(
        arrow_left[0],

Year-over-Year Change Analysis#

The first visualization examines year-over-year population changes, normalized by z-scores to compare states on the same scale. The plot highlights periods where California and Texas growth rates diverged significantly, using filled areas and arrows to mark those intervals.

YoY change calculation and plotting#

plt.figure(figsize=(15, 10))
plt.gca().yaxis.set_major_formatter(FuncFormatter(percent_formatter))
plt.plot(california_change.index, california_zscore, marker='o', label='California', color=COLOR1)
plt.plot(texas_change.index, texas_zscore, marker='o', label='Texas', color=COLOR2)
for i in range(len(california_zscore) - 1):
    fill_data = get_fill_data(i, california_change, texas_change, california_zscore, texas_zscore)
    ca_change = fill_data.change1
    tx_change = fill_data.change2
    plot_fill(ca_change, tx_change, fill_data)
plt.title('Normalized Year-over-Year Percentage Change in Population for California and Texas')
plt.xlabel('Year')
plt.ylabel('Z-Score of % Change')
draw_legend('California', 'Texas')
plt.grid(True)
plt.show()

Year-over-year population change plot with z-score normalization

Rank Change Visualization#

This plot shows how states’ population ranks shifted from 2013 to 2022, with bars representing 2022 populations and curved arrows indicating rank changes. States that moved up or down in ranking are highlighted with colored bars and connecting arcs.

Rank change plotting with custom legend handler#

class HandlerArrowLine(HandlerLine2D):
    def create_artists(self, legend, orig_handle, xdescent, ydescent, width, height, fontsize, trans):
        # Create a line and an arrowhead as separate artists
        padding = 2
        line = Line2D([xdescent + padding, width - xdescent], [height / 2, height / 2], linestyle=orig_handle.get_linestyle(), color=orig_handle.get_color())
        arrow = Line2D([xdescent + padding], [height / 2], marker='<', color=orig_handle.get_color(), markersize=fontsize / 2, linestyle='None')
        return [line, arrow]

plt.figure(figsize=(15, 10))
plt.gca().yaxis.set_major_formatter(FuncFormatter(millions_formatter))
bars_2022 = plt.bar(pop_2022_sorted.index, pop_2022_sorted, color=COLOR5)
plt.title('Relative population rank change between 2013 and 2022')
plt.xlabel('State')
plt.ylabel('Population')
plt.xticks(rotation=90)

line_handles = [
    Line2D([0], [1], color=COLOR3, marker='<', linestyle='-', label='rank change'),
    Line2D([0], [1], color=COLOR1, marker='<', linestyle='-', label='top three largest rank changes'),
    Line2D([0], [1], color=COLOR2, marker='<', linestyle='-', label='top three smallest rank changes'),
]
block_handles = [
    patches.Patch(color=COLOR5, label='Population & unchanged rank'),
    patches.Patch(color=COLOR4, label='Population & changed rank')
]
plt.legend(handles=line_handles + block_handles,  handler_map={handle: HandlerArrowLine() for handle in line_handles}).get_frame().set_alpha(1)
ax = plt.gca()
for bar, state in zip(bars_2022, pop_2022_sorted.index):
    if state in changed_states:
        bar.set_color(COLOR4)
        prev_pos = order_2013.index(state)
        new_pos = order_2022.index(state)
        con = ConnectionPatch(
            xyA=(prev_pos, pop_2013_sorted[state]),
            xyB=(new_pos, pop_2022_sorted[state]),
            coordsA="data", coordsB="data",
            axesA=ax, axesB=ax,
            color=COLOR1 if state in top_3_states_by_position_change else (COLOR2 if state in bottom_3_states_by_position_change else COLOR3),
            arrowstyle=ArrowStyle("simple", head_width=1, head_length=1, tail_width=0.1), 
            fill=True,
            linewidth=1,
            connectionstyle="arc3,rad=0.9"
        )
        ax.add_patch(con)
plt.show()

Population rank change visualization with arrows

Average Annual Growth Rate Map#

The final visualization maps average annual growth rates across all states using a color gradient, with vertical markers for California and Texas. The horizontal color bar provides context for the growth spectrum from highest growth to population loss.

Gradient colormap visualization#

colors = ["green", "yellow", "red"]
cmap = LinearSegmentedColormap.from_list("mycmap", colors)
norm = plt.Normalize(0, len(average_annual_rate_of_change_sorted) - 1)
fig, ax = plt.subplots(figsize=(15, 10))
plt.gca().yaxis.set_major_formatter(FuncFormatter(percent_formatter))
bars = plt.bar(
    average_annual_rate_of_change_sorted.index,
    average_annual_rate_of_change_sorted,
    color=[cmap(norm(i)) for i in range(len(average_annual_rate_of_change_sorted))],
    zorder=2 # hide grid behind bars
)
ax = plt.gca()
for state in ['California', 'Texas']:
    idx = average_annual_rate_of_change_sorted.index.get_loc(state)
    bar = bars[idx]
    x = bar.get_x() + bar.get_width() / 2
    ax.axvline(x=x, color='red', linestyle='--', linewidth=1)
plt.title('Average Annual Rate of Change in Population for All States')
plt.xlabel('State')
plt.ylabel('Average Annual Rate of Change (%)')
plt.xticks(rotation=90)
plt.grid(True, zorder=0) # hide grid behind bars
sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
sm.set_array([])
sm.set_clim(0, len(average_annual_rate_of_change_sorted) - 1)
cbar_ax = fig.add_axes([0.161, 0.86, 0.698, 0.02])
cbar = plt.colorbar(sm, cax=cbar_ax, orientation='horizontal')
cbar.set_ticks([])
cbar_ax.text(0.0, 0.5, 'Highest Growth', va='center', ha='left', color='white', fontweight='bold', transform=cbar_ax.transAxes)
cbar_ax.text(0.5, 0.5, 'Moderate Growth', va='center', ha='center', color='black', fontweight='bold', transform=cbar_ax.transAxes)
cbar_ax.text(1.0, 0.5, 'Loss', va='center', ha='right', color='white', fontweight='bold', transform=cbar_ax.transAxes)
plt.show()

The full analysis including charts and findings is available in the Jupyter notebook:

PopulationAnalysis.ipynb

Conclusion#

In the end, this take-home took raw JSON and turned it into a clean CSV by breaking it down into small, clear steps. That makes it simple to test and audit, and gets you ready for the analysis. The practical approach-caching to skip repeated API calls, clear key mappings, and straightforward validation- shows good thinking and communication, not unnecessary complexity.

On this page