Trader Joe's NYC Location Analysis

By: Logan Chalifour

Instructions

Where in New York City would you advise Trader Joe’s to open their next store?

Import Packages

We start by importing some packages needed for our analysis.

import numpy as np import pandas as pd import geopandas as gpd import re import json import plotly.express as px import plotly.graph_objects as go import plotly.io as pio from sklearn.preprocessing import MinMaxScaler

Define Functions

We define some functions that we will use throughout our notebook. The nyc-zip-code-tabulation-areas-polygons.geojson file is sourced from a repo on GitHub. Explanations of the code can be found inline.

# NYC and Manhattan center point used for plots nyc_center={'lat': 40.710, 'lon': -73.985} man_center={'lat': 40.785, 'lon': -73.971} # Function for extracting coordinates from georeference point column def extract_coordinates(georeference): # Example format: 'POINT (-73.71744 40.74408)' lat_lon = georeference.replace('POINT (', '').replace(')', '').split() # Replace and split return float(lat_lon[1]), float(lat_lon[0]) # Return latitude first, then longitude # Function to find wildcard match using regex def wildcard_match(pattern, string): # Pass pattern to and string to search for return bool(re.search(pattern, string, flags=re.IGNORECASE)) # Search with case ignored # Function to make plot of individual stores def make_store_plot(df, title, opacity=1, color_column=None, color=None, center=nyc_center, zoom=10, save=False): # If to be saved if save == True: zoom = 10.5 # Create a plot of stores with coordinates fig = px.scatter_mapbox( df, lat='Latitude', lon='Longitude', hover_name='DBA Name', hover_data={'Address': True, 'License Number': True, 'Type': True, 'Chain': True}, mapbox_style='carto-positron' ) # Multi-color if color_column is not None: color_discrete_map = { 'SMALL': '#0288D1', # Blue 'LARGE CHAIN': '#66BB6A', # Green 'TRADER JOE\'S': '#EF5350' # Red } fig.update_traces(marker=dict(color=df[color_column].map(color_discrete_map))) # One color passed elif color is not None: fig.update_traces(marker=dict(color=color)) # User color # Default coloring else: fig.update_traces(marker=dict(color='#0288D1')) # Blue # Update point size and opacity fig.update_traces(marker=dict(size=5, opacity=opacity), selector=dict(mode='markers')) # Set the aspect ratio and formatting fig.update_layout( title=title, mapbox=dict(style='carto-positron', zoom=zoom, center=center), autosize=True, margin={"r":0,"t":0,"l":0,"b":0} ) # Save the plot if save == True: pio.write_image(fig, 'stores_fullscreen.png', width=1920, height=1080) # Show the plot elif save == False: fig.show() # Create zip code plot with stores overlayed def make_zip_plot(df, stat_column, store_df=None, subway_df=None, center=nyc_center, zoom=10, save=False): # Load the GeoJSON file with zip code boundaries with open('nyc-zip-code-tabulation-areas-polygons.geojson') as file: geojson_data = json.load(file) # If to be saved if save == True: zoom = 10.5 # If final recommendation plot if stat_column == 'Weighted Location Score': hover = ['Borough', 'Score | Population per Store', '2023 Population per Store', 'Score | Population per Chain', '2023 Population per Chain', 'Score | Population Growth Rate', '2-year Population Growth Rate', 'Weighted Location Score'] else: hover = ['Zip Code', 'Borough', stat_column] # Create a choropleth map of the zip code data fig = px.choropleth_mapbox( df, geojson=geojson_data, locations='Zip Code', featureidkey='properties.postalCode', color=stat_column, color_continuous_scale='YlOrRd', center=center, mapbox_style='carto-positron', zoom=zoom, opacity=.3, labels={stat_column: stat_column}, title=f'{stat_column} by Zip Code', hover_data=hover ) # IF plotting stores too if store_df is not None: # Add store locations as scatter plot fig.add_trace( go.Scattermapbox( lat=store_df['Latitude'], lon=store_df['Longitude'], mode='markers', marker=dict( size=8, color='#EF5350', # Red opacity=1 ), hoverinfo='text', customdata=store_df[['DBA Name', 'Address', 'License Number', 'Latitude', 'Longitude']], hovertemplate= "DBA Name: %{customdata[0]} " "Address: %{customdata[1]} " + "License Number: %{customdata[2]} " + "Latitude: %{customdata[3]} " + "Longitude: %{customdata[4]} ", showlegend=False, name='Store' ) ) # If plotting subways too if subway_df is not None: # Add subway locations as scatter plot fig.add_trace( go.Scattermapbox( lat=subway_df['Latitude'], lon=subway_df['Longitude'], mode='markers', marker=dict( size=4, color='black', # Black opacity=1 ), hoverinfo='text', customdata=subway_df[['NAME', 'LINE', 'NOTES', 'Latitude', 'Longitude']], hovertemplate= "Name: %{customdata[0]} " + "Line: %{customdata[1]} " + "Notes: %{customdata[2]} " + "Latitude: %{customdata[3]} " + "Longitude: %{customdata[4]} ", showlegend=False, name='Subway Stop' ) ) # Set the aspect ratio fig.update_layout( autosize=True, margin={"r": 0, "t": 0, "l": 0, "b": 0} ) # Save the plot if save == True: pio.write_image(fig, 'scores_fullscreen.png', width=1920, height=1080) # Show the plot elif save == False: fig.show() # Function used to generate dfs by borough def generate_filtered_dfs(df, column_name, values): filtered_dataframes = [] for value in values: filtered_dataframe = df[df[column_name] == value].reset_index(drop=True) filtered_dataframes.append(filtered_dataframe) return filtered_dataframes # Retruns multiple dfs # Calculates normalized scores and weighted location score for the given dataframe. def calculate_scores(df, pop_per_store_weight=.4, pop_per_chain_weight=.4, pop_growth_rate_weight=.2, scaler=MinMaxScaler()): # Calculate normalized scores df['Score | Population per Store'] = np.round(100 * scaler.fit_transform(df[['2023 Population per Store']]), 2) df['Score | Population per Chain'] = np.round(100 * scaler.fit_transform(df[['2023 Population per Chain']]), 2) df['Score | Population Growth Rate'] = np.round(100 * scaler.fit_transform(df[['2-year Population Growth Rate']]), 2) # Calculate weighted location score df['Weighted Location Score'] = np.round(pop_per_store_weight * df['Score | Population per Store'] + pop_per_chain_weight * df['Score | Population per Chain'] + pop_growth_rate_weight * df['Score | Population Growth Rate'], 2) # Sort the DataFrame by the Weighted Location Score column df = df.sort_values('Weighted Location Score', ascending=False) # Return df return df

Import Data

NYC Retail Food Stores CSV (retail food stores licensed by the Department of Agriculture and Markets)

2021 NYC Population by Zip Code

2023 NYC Population by Zip Code

NYC Subway Stations

GeoJSON File for NY Zip Codes

GeoJSON File for FRESH Food Stores Zoning Boundaries

# 1. read csv as store_df store_df = pd.read_csv('Retail_Food_Stores.csv') # 2. read csv as pop_2021_zip_df pop_2021_zip_df = pd.read_csv('2021_ny_zip_populations.csv') # 3. read csv as pop_2023_zip_df pop_2023_zip_df = pd.read_csv('2023_ny_zip_populations.csv') # 4. read csv as subway_df subway_df = pd.read_csv("DOITT_SUBWAY_STATION_01_13SEPT2010.csv")

Let's look at the store_df with all retail food stores which are licensed by the Department of Agriculture and Markets in the state of New York. Naturally, we will have to filter this dataset to include only grocery stores in New York City since a lot of the rows are not true grocery stores or are outside of the five boroughs.

store_df

Now, let's look at the pop_2021_zip_df which we will use in hand with 2023 figures to compute the population growth rate for each zip code.

pop_2021_zip_df

Let's also view the pop_2023_zip_df which has the most current population figures by zip code.

pop_2023_zip_df

Lastly, let's look at the subway_df which has information about all the subway stops in the city.

subway_df

Inputs and Assumptions

The lists below were created based on personal assumptions about what words should and should not be included in filters for grocery stores. Keywords were added/removed manually by iteratively viewing the filtered results. The assumptions can be edited as needed to change the resulting list of grocery stores for the analysis. Fuzzy matching was attempted, but too many intricacies in the store names still existed for filtering to work appropriately.

# Mapping from county to borough county_mapping = { 'New York': 'Manhattan', 'Kings': 'Brooklyn', 'Bronx': 'Bronx', 'Queens': 'Queens', 'Richmond': 'Staten Island' } # Define the wildcard keywords for filtering stores keywords = [ "GROCERIES", "GROCERY", "MARKET", "MART", "MRKT", "MKT", "ORGANIC", "PANTRY", "PRODUCE", "SUPER", "WHOLESALE" ] # Stores should not include these wildcard keywords; often niche stores that should not be included remove_keywords = [ "@", " at ", " by ", "BAKE", "CANDY", "CONV", "DASHMART", "DOLLAR", "EXP", "FISH", "FRUIT", "HALLAL", "MEAT", "MINI", "MOBIL", "SEAFOOD", "SMOKE", "SUSH", "VEGET" ] # Specify wildcards accepted for each store; iterative process addded to manually stores = { "ANTILLANA SUPERFOOD MARKET": ["ANTILLANA"], "ASSOCIATED SUPERMARKETS": ["ASSOCIATED"], "BJS WHOLESALE": ["BJS"], "BRAVO SUPERMARKET": ["BRAVO"], "BROOKLYN HARVEST MARKET": ["BROOKLYN HARVEST MARKET"], "C-TOWN SUPERMARKET": ["C-TOWN", "CTOWN", "C TOWN"], "CITY ACRES MARKET": ["CITY ACRES MARKET"], "CITY FRESH MARKET": ["CITY FRESH MARKET"], "CITARELLA": ["CITARELLA"], "COMPARE FOODS": ["COMPARE"], "COSTCO WHOLESALE": ["COSTCO"], "D'AGOSTINOS": ["AGOSTINO"], "EATALY": ["EATALY"], "FAIRWAY": ["FAIRWAY"], "FINE FARE": ["FINE FARE"], "FOOD BAZAAR": ["FOOD BAZAAR"], "FOOD EMPORIUM": ["FOOD EMPORIUM"], "FOODTOWN": ["FOODTOWN", "FOOD TOWN"], "FOOD UNIVERSE": ["FOOD UNIVERSE"], "GRISTEDES": ["GRISTEDE"], "H MART": ["H-MART", "HMART", "H MART"], "HUDSON MARKET": ["HUDSON MARKET"], "IDEAL FOOD BASKET": ["IDEAL FOOD BASKET"], "KEY FOOD": ["KEY FOOD", "KEYFOOD"], "LINCOLN MARKET": ["LINCOLN MARKET"], "MET FRESH": ["MET FRESH"], "MET FOOD": ["MET FOOD"], "MORTON WILLIAMS": ["MORTON WILLIAM"], "NET COST MARKET": ["NET COST", "NETCOST"], "PIONEER SUPERMARKETS": ["PIONEER"], "PREMIUM SUPERMARKET": ["PREMIUM SUPERMARKET"], "SHOP FAIR": ["SHOP FAIR"], "SUPER FRESH": ["SUPER FRESH", "SUPERFRESH"], "TARGET": ["TARGET"], "TRADER JOE'S": ["TRADER JOE"], "UNION MARKET": ["UNION MARKET"], "USA SUPERSTORES": ["USA SUPERSTORE"], "WESTSIDE MARKET": ["WESTSIDE", "WEST SIDE"], "WHOLE FOODS MARKET": ["WHOLE FOOD"], "ZABAR'S": ['ZABARS'] }

We also add two Trader Joe's stores that are missing from the dataset after a manual check. Please see here for info regarding the new stores that opened in Queens in 2021 and 2023. Coordinates for the stores were generated using the Mapquest site. All other Trader Joe's locations were checked and present in the dataset, so no need for additional entries.

# Add rows for new Trader Joe's after manual spot check new_rows = [ { 'County': 'Queens', 'License Number': 'N/A', 'Operation Type': 'Store', 'Establishment Type': 'A', 'Entity Name': 'TRADER JOES EAST INC', 'DBA Name': 'TRADER JOES #578', 'Street Number': '69-65', 'Street Name': 'YELLOWSTONE BLVD', 'Address Line 2': '', 'Address Line 3': '', 'City': 'QUEENS', 'State': 'NY', 'Zip Code': '11375', 'Square Footage': 0, 'Georeference': 'POINT (-73.84861 40.72272)', 'NYS Municipal Boundaries': 'N/A' }, { 'County': 'Queens', 'License Number': 'N/A', 'Operation Type': 'Store', 'Establishment Type': 'A', 'Entity Name': 'TRADER JOES EAST INC', 'DBA Name': 'TRADER JOES #565', 'Street Number': '22-43', 'Street Name': 'JACKSON AVE', 'Address Line 2': '', 'Address Line 3': '', 'City': 'QUEENS', 'State': 'NY', 'Zip Code': '11101', 'Square Footage': 0, 'Georeference': 'POINT (-73.94607 40.74567)', 'NYS Municipal Boundaries': 'N/A' } ] # Append the new rows to store_df store_df = store_df.append(new_rows, ignore_index=True)

Data Preparation

With the inputs above, we prepare the dataset for our analysis by filtering, dropping rows/columns, creating new columns, etc.

# Revese stores dictionary for lookup later on reversed_stores = {value: key for key, values in stores.items() for value in values} # Create combined list for filter later on combined_keyword_store = keywords + list(reversed_stores.keys()) # Drop unused columns columns_to_drop = ['Address Line 2', 'Address Line 3'] store_df = store_df.drop(columns_to_drop, axis=1) # Drop missing rows for key columns needed_columns = ['Georeference', 'Street Number', 'DBA Name'] store_df = store_df.dropna(subset=needed_columns) # Create boroughs column and filter for NYC only store_df['Borough'] = store_df['County'].map(county_mapping).fillna('Other') valid_boroughs = list(county_mapping.values()) store_df = store_df[store_df['Borough'].isin(valid_boroughs)] # Extract lat and long store_df[['Latitude', 'Longitude']] = store_df['Georeference'].apply(lambda x: pd.Series(extract_coordinates(x))) # Create address column store_df['Address'] = store_df['Street Number'] + ' ' + store_df['Street Name'] + ', ' + store_df['City'] + ', ' + store_df['State'] + ' ' + store_df['Zip Code'].astype(str) # Create pattern string for seaching keywords/stores pattern = '|'.join([re.escape(word) for word in combined_keyword_store]) # Create a boolean mask indicating rows with column values containing any of the keywords or store wildcards mask = (store_df['DBA Name'].str.contains(pattern, regex=True, na=False) | store_df['Entity Name'].str.contains(pattern, regex=True, na=False)) # Apply the mask to filter the DataFrame filtered_df = store_df[mask] # Additional filtering to exclude rows with specific keywords in DBA or entity columns filtered_df = filtered_df[~(filtered_df['DBA Name'].str.contains('|'.join(remove_keywords), case=False) | filtered_df['Entity Name'].str.contains('|'.join(remove_keywords), case=False))] # Create a chain column for major chains by mapping DBA column using the reversed stores dictionary with wildcard matching filtered_df['Chain'] = filtered_df['DBA Name'].apply(lambda x: next((value for key, value in reversed_stores.items() if wildcard_match(key, x)), 'N/A')) # Create yes or no for large chain derived from chain filtered_df['Large Chain'] = filtered_df['Chain'].apply(lambda x: 'No' if x == 'N/A' else 'Yes') # Create new column for type filtered_df["Type"] = filtered_df["Chain"].apply(lambda x: "SMALL" if x == "N/A" else "TRADER JOE'S" if x == "TRADER JOE'S" else "LARGE CHAIN") # Create df for large chains only chain_df = filtered_df[(filtered_df['Large Chain'] == 'Yes')] # Create df for non-large chains non_chain_df = filtered_df[(filtered_df['Chain'] == 'N/A')] # Create df for TJ's only tj_df = filtered_df[filtered_df['Chain'] == "TRADER JOE'S"] # Group by zip code and count stores store_zip_df = filtered_df.groupby(['Zip Code', 'Borough']).size().reset_index(name='Number of Stores') # Create and merge chain_zip_df chain_zip_df = chain_df.groupby(['Zip Code']).size().reset_index(name='Number of Chains') zip_df = store_zip_df.merge(chain_zip_df, on='Zip Code', how = 'outer') # Merge store_zip_df and pop_2021_zip_df zip_df = zip_df.merge(pop_2021_zip_df, on='Zip Code', how='outer') # Replace nan population with zero and convert to float zip_df['Population'] = zip_df['Population'].fillna(0) zip_df['Population'] = zip_df['Population'].str.replace(',', '').astype(float) # Merge pop_2023_zip_df pop_2023_zip_df = pop_2023_zip_df.drop(['city', 'county'], axis=1) zip_df = zip_df.merge(pop_2023_zip_df, left_on='Zip Code', right_on='zip', how='outer') # Rename and drop columns zip_df = zip_df.rename(columns={'Population': '2021 Population', 'population': '2023 Population'}) zip_df = zip_df.drop(['zip'], axis=1) # Use 2021 populations for missing 2023 populations zip_df['2023 Population'] = zip_df.apply(lambda row: row['2021 Population'] if pd.isnull(row['2023 Population']) else row['2023 Population'], axis=1) # Create new columns by zip code and round zip_df['2-year Population Growth'] = zip_df['2023 Population'] - zip_df['2021 Population'] zip_df['2021 Population per Store'] = np.round(zip_df['2021 Population'] / zip_df['Number of Stores'], 2) zip_df['2023 Population per Store'] = np.round(zip_df['2023 Population'] / zip_df['Number of Stores'], 2) zip_df['2-year Population Growth Rate'] = np.round(zip_df['2-year Population Growth'] / zip_df['2021 Population per Store'], 4) zip_df['Population Per Store Growth'] = np.round(zip_df['2-year Population Growth'] / zip_df['Number of Stores'], 2) zip_df['2021 Population per Chain'] = np.round(zip_df['2021 Population'] / zip_df['Number of Chains'], 2) zip_df['2023 Population per Chain'] = np.round(zip_df['2023 Population'] / zip_df['Number of Chains'], 2) zip_df['2-year Population Growth Rate'] = np.round(zip_df['2-year Population Growth'] / zip_df['2021 Population per Chain'], 4) zip_df['Population Per Chain Growth'] = np.round(zip_df['2-year Population Growth'] / zip_df['Number of Chains'], 2) # Replace nan's with zero zip_df = zip_df.fillna(0) # Filter for boroughs only zip_df = zip_df[zip_df['Borough'].isin(county_mapping.values())] # Subway df subway_df[['Latitude', 'Longitude']] = subway_df['the_geom'].apply(lambda x: pd.Series(extract_coordinates(x)))

EDA

Let's now take a look at the resulting dataframes filtered_df representing all grocery stores in the city, tj_df which represents all Trader Joe's stores in the city, and zip_df with a summary of each zip code's store count and population figures.

filtered_df

tj_df

zip_df

In total, there are 4,631 grocery stores in all five boroughs of New York City; sixteen of which are Trader Joe's locations. Below, we see the most common grocery chains in New York City, with the most frequent being Key Food with 90 locations. Once again, we see Trader Joe's with sixteen locations across the city, making it the thirteenth most common chain by number of stores.

filtered_df['Chain'].value_counts()

Individual Grocery Stores

Let's start by getting an idea of where Trader Joe's sixteen current stores are located across the city. For all the plots below, you can interactively learn more about each store by hovering over the points. You can also pan around the map while zooming in and out.

make_store_plot(tj_df, "Trader Joe's Stores in NYC", opacity = 1, color = '#EF5350') # Red

Now, let's get an idea of how all 4,631 grocery stores look on a map of New York City. Red points represent Trader Joe's, green points represent other major chains, and blue points represent non-major chain stores. Again, you may want to pan around while zooming in and out to explore further.

make_store_plot(filtered_df, "All Grocery Stores in NYC", color_column = 'Type', opacity = 1, save=True) make_store_plot(filtered_df, "All Grocery Stores in NYC", color_column = 'Type', opacity = 1)

Zip Code Analysis

As one would expect, viewing over 4,000 stores on one plot can be a bit overwhelming, so we aggregate the number of stores by zip code for ease of viewing. Dark red zip codes represent a high number of stores, while lighter colors represent a lower number of stores. You can also see the Trader Joe's locations as red points to get a sense of where their stores already are.

make_zip_plot(zip_df, 'Number of Stores', tj_df)

What about the number of large chains instead of just stores? As we know, chain grocery stores are typically much larger and attract many more shoppers than small corner grocery stores. Having an idea of where there is a lack of large chains could signal where we should open a new Trader Joe's store.

make_zip_plot(zip_df, 'Number of Chains', tj_df)

In addition to the number of stores, let's look at the population by zip code, specifically for 2023.

make_zip_plot(zip_df, '2023 Population', tj_df)

Let's contextualize the plots above by dividing each zip code's population by the number of stores/chains. Ideally, we would want to place a new Trader Joe's store in a zip code that has an already high population-to-store or population-to-chain ratio. As a result, we would expect less competition among grocery stores and more traffic to our new store. Essentially, red zones on the plot represent high-potential opportunities for opening a new Trader Joe's location.

make_zip_plot(zip_df, '2023 Population per Store', tj_df) make_zip_plot(zip_df, '2023 Population per Chain', tj_df)

A common theme across the two previous plots is a higher population per store and chain in the boroughs outside of Manhattan. For example, certain zip codes in Staten Island have a population per store near 20k with higher ratios also in Queens. This makes sense because shoppers are more likely to travel long distances to stores because more people have cars outside of Manhattan. Thus, fewer stores are needed in comparison to Manhattan. Let's look at only Manhattan so the scale adjusts and we can see more variation in the map.

make_zip_plot(zip_df[zip_df['Borough'] == 'Manhattan'], '2023 Population per Store', tj_df[tj_df['Borough'] == 'Manhattan'], center=man_center, zoom=10.5) make_zip_plot(zip_df[zip_df['Borough'] == 'Manhattan'], '2023 Population per Chain', tj_df[tj_df['Borough'] == 'Manhattan'], center=man_center, zoom=10.5)

As you can see, zip codes within the Upper West Side and Upper East Side and other pockets such as Two Bridges typically have a higher population per store and/or chain. Certain zip codes in Washington Weights and Inwood have a high population per chain, but not per store. Thus, these may be good locations for a new store that we will keep in mind.

Another factor to consider when placing a new Trader Joe's store is making sure the population of a zip code is increasing. If possible, we may want to avoid opening a new location in a zip code where the population is shrinking and thus, there are fewer shoppers. The plot below highlights zip codes in red with high population growth rates from 2021 to 2023.

make_zip_plot(zip_df, '2-year Population Growth Rate', tj_df)

As you can see in the map above, Williamsburg (zip code: 11211) is clearly a booming neighborhood with a population growth of roughly 4.5% from 2021 to 2023. Most other neighborhoods have remained flat or moderately increased/decreased by less than a percent, likely due to individuals leaving the city during the height of COVID. Thus, Williamsburg may be a good spot for a new Trader Joe's location, even though it has one store already.

Zip Code Scoring

There are many different plots above that each tells a different story regarding New York City and where might be an optimal location for the next Trader Joe's store. To aggregate these findings, we build a Weighted Location Score that can range from 0-100. The score combines weighted normalized scores from zero to one for 2023 Population per Store, 2023 Population per Chain, and 2-year Population Growth. Currently, the weights are set in the function itself and they can be adjusted if needed:

pop_per_store_weight = .4

pop_per_chain_weight = .4

pop_growth_rate_weight = .2

Let's compute the location scores using the weights above, normalized at the borough level. The choice to normalize the scores by the borough as opposed to altogether was made because expected population per store/chain and overall population growth looks very different in densely populated urban areas such as Manhattan when compared to other more suburban boroughs such as Staten Island. For example, we see and would expect a higher population per store/chain in those suburban areas since people are more likely to get in their car and drive to stores further away, compared to most individuals in Manhattan without a car. As a result, we normalize the values by each borough between zero and one, accounting for variance.

# Generate dfs for each borough borough_dfs = generate_filtered_dfs(zip_df, 'Borough', county_mapping.values()) manhattan_df = borough_dfs[0] brooklyn_df = borough_dfs[1] bronx_df = borough_dfs[2] queens_df = borough_dfs[3] staten_df = borough_dfs[4] # Calculate location scores manhattan_df = calculate_scores(manhattan_df) brooklyn_df = calculate_scores(brooklyn_df) bronx_df = calculate_scores(bronx_df) queens_df = calculate_scores(queens_df) staten_df = calculate_scores(staten_df) # Combine back to zip_df zip_df = pd.concat([manhattan_df, brooklyn_df, bronx_df, queens_df, staten_df], ignore_index=True) # Sort by score zip_df = zip_df.sort_values(by="Weighted Location Score", ascending=False)

Below, you see the zip_df including a new column with the overall Weighted Location Score. sorted from highest to lowest. A higher population per store, higher population per chain, and higher population growth rate will all contribute to a higher location score, which can range from zero to one hundred. Although no zip code received a score of one hundred, high location scores represent the “best” potential zip codes for a new Trader Joe’s store, while low location scores represent the “worst” zip codes for a new Trader Joe’s store.

zip_df

With our scores derived, we visualize them on a map of the city, again with existing Trader Joe's stores represented by red points and now included subway stops in black. You can pan around the map and hover over points/zip codes to learn more about the data, including specific score breakdowns.

make_zip_plot(zip_df, 'Weighted Location Score', tj_df, subway_df) make_zip_plot(zip_df, 'Weighted Location Score', tj_df, subway_df, save=True)

The maximum score we see is ~98 in the Bronx for zip code 10475. The lowest score we see is ~6 also in the Bronx for zip code 10452. Although subway proximity was not included in the Weighted Location Score, it's helpful to see where the stops are to get an understanding of how accessible a zip code may be for shoppers willing to travel via subway. As we know, the subway is the most popular form of transportation in New York City, and placing a new Trader Joe's store close to a subway increases the number of potential shoppers and thus store revenues.

FRESH Food Stores Zoning Boundaries

We also look at local tax incentives to help decide on the optimal location for a new Trader Joe's store. We pull data from NYC Open Data for FRESH boundaries which provide tax advantages to new grocery stores opening in certain areas of New York City. According to the dataset description, the benefits are as follows: "FRESH boundaries where zoning and discretionary tax incentives are available for the development, expansion and renovation of full line grocery stores and supermarkets. The FRESH II Text amendment adopted on 12/15/2021 expanded the program to other underserved neighborhoods of the Bronx, Brooklyn, Queens and Staten Island and modified the rules for certification of a FRESH food store." This should not be the primary driver for deciding where to open a new Trader Joe's location (which is why it wasn't included in the weighted location score in the previous section), but it can serve as a potential differentiator for deciding between two locations.

# Read GeoJSON file gdf = gpd.read_file('FRESH Food Stores Zoning Boundaries.geojson') # Create map of FRESH zones fig = px.choropleth_mapbox(gdf, geojson=gdf.geometry, locations=gdf.index, color_continuous_scale="Viridis", mapbox_style="carto-positron", center=nyc_center, zoom=10.5, opacity=0.25, title ='FRESH Tax-Advantaged Boundaries' ) # Update margins fig.update_layout(margin={"r":0,"t":0,"l":0,"b":0}) # Save map pio.write_image(fig, 'fresh_fullscreen.png', width=1920, height=1080) # Update zoom to 10 fig.update_layout(mapbox=dict(zoom=10)) # Show plot fig.show()

Above you see that almost the entirety of the Bronx and several across the rest of New York City are eligible for the FRESH tax-advantaged program. We will revisit this map later to help decide on an optimal location.

Final Recommendation

With the data provided above, I return the top-scoring zip code for each borough. I manually filtered out Manhattan’s highest-scoring zip code in Roosevelt’s Island (10044) since it’s unlikely residents from other zip codes would shop there due to its isolated nature. I also strip out a zip code in Washington Heights (10039) to keep the suggestion for Manhattan further downtown. This is acceptable since the location scores of the top three zip codes in Manhattan were all relatively close in the 60-70 range.

# Filter out zip code 10044 for Roosevelt Island and 11355 for non-uptown recommendation rec_df = zip_df[(zip_df['Zip Code'] != 10044) & (zip_df['Zip Code'] != 10039)] # Calculate top scores for each borough, excluding zip code 10044 and 11355 top_scores = rec_df.groupby('Borough')['Weighted Location Score'].agg('max') # Merge with the original DataFrame to get all identifying columns final_df = pd.merge(rec_df, top_scores, on=['Borough', 'Weighted Location Score'], how='inner') # Show final DataFrame final_df

My recommendation is to open a new Trader Joe’s store in one of the zip codes above. As expected, there is no right or wrong answer here necessarily, but rather a relative strength of the recommendation. In this case, I would recommend placing the new store somewhere in Manhattan as opposed to one of the other boroughs. This is because nine of Trader Joe’s sixteen existing stores in New York City are located within Manhattan, suggesting it fits their customer base the best.

With a population of roughly 24,000 in 2023 and a two-year population growth of roughly .5%, Two Bridges of downtown Manhattan is an optimal location for a new Trader Joe’s store when compared to other zip codes. It has eleven existing grocery stores, only one of which is a large chain (CTown Supermarkets). Thus, the normalized scores for population per store and chain come in at ~34 and ~89 respectively, with a population growth rate scoring at ~64 – meaning the 10038-zip code represents a high potential opportunity with less competition from existing grocery stores and modest population growth. After applying the weights, we arrive at the weighted location score of ~62, the highest in Manhattan (after filtering out two zip codes) and the overall best recommendation for a new Trader Joe’s location. As you can see from the plot above, the closest Trader Joe’s is in the Lower East Side, so being too close to an existing store is not a concern. Additionally, there are plenty of subway stops that provide easy transportation to the Two Bridges area.

Lastly, Two Bridges is eligible for local tax incentives for new grocery stores within the FRESH zoning tax benefits shared in the previous section. Even though FRESH zoning boundaries were not included in the weighted location score, it is an important factor that can help us decide between multiple options. Because Two Bridges is eligible for the FRESH tax advantage, it ends up as an even better location for a new Trader Joe’s store.