Trip Planning with Electric Vehciles
Problem
Long-distance travel with electric vehicles introduces planning challenges that do not exist for internal combustion vehicles. EV drivers must account for charging station availability, charger compatibility, charging speed, and proximity to a planned route while also considering vehicle range constraints and personal preferences such as amenities or desired state of charge. Existing consumer tools often obscure these variables and do not provide transparency into how routing and charger selection decisions are made. The problem addressed in this project was how to programmatically identify and visualize optimal EV charging locations along a route using authoritative national data while giving the user control over routing and range parameters.
Analysis Procedures
This project was implemented as a Python script tool within ArcGIS Pro using ArcPy and the Network Analyst extension. A national EV charging station dataset from the Joint Office of Energy and Transportation was read and processed from CSV format and parsed to retain only relevant records, filtering out restricted-access stations and chargers without compatible CCS connectors. The cleaned dataset was written to a geodatabase table and converted into a spatial point feature class. A network route analysis layer was then created using user-defined origin and destination coordinates. The script programmatically added route stops, solved the network, and generated points along the route at regular distance intervals corresponding to half of the vehicle’s maximum driving range. Charging stations located within a specified buffer distance of the route were selected and copied to a new feature class. These candidate charging locations were symbolized alongside the route and range markers, and turn-by-turn driving directions were generated automatically. Object-oriented programming was used to encapsulate routing and charger-selection logic within a custom EVRoutePlanner class, improving code readability and extensibility.
Results
The final output of the project is a fully automated ArcGIS Pro script tool that produces a mapped EV travel route, identifies viable charging stations near the route, displays range-based interval markers, and generates turn-by-turn driving directions. The tool successfully integrates large national datasets with network analysis and spatial filtering to provide actionable travel guidance. Results are visualized directly in the map interface, allowing users to inspect individual charging station attributes such as connector counts, charging speed, and location context. The workflow demonstrates how GIS programming can bridge raw infrastructure data and practical transportation decision-making.
Reflection
In this project, I developed a Python-based GIS automation tool that integrates national EV charging infrastructure data with network route analysis in ArcGIS Pro. I designed the workflow to import, filter, spatially process, and visualize charging stations relative to a user-defined travel route, while encapsulating core logic in reusable functions and a custom class structure. This project significantly strengthened my programming competency within a GIS context. I gained hands-on experience working with large tabular datasets, converting them into spatial features, managing geodatabases, and programmatically controlling ArcGIS Pro projects. Implementing a custom class for route planning deepened my understanding of object-oriented programming in Python, while troubleshooting Network Analyst workflows improved my ability to interpret ESRI documentation and debug complex geoprocessing errors. The project also reinforced best practices for building script tools that are usable by non-programmers. What I learned through this project matters because modern GIS roles increasingly require the ability to automate workflows, integrate external datasets, and build repeatable analytical tools rather than relying solely on manual processes. This experience demonstrated how programming extends GIS from static analysis to dynamic decision-support systems. The skills developed here—ArcPy scripting, network analysis automation, data validation, and modular code design—are directly transferable to enterprise GIS, transportation planning, and geospatial application development, making this project a strong representation of my programming competency.
Automated Data Ingestion and Enterprise Geodatabase Provisioning Using ArcPy and Python
Problem
The Resilient Coastal Communities Program (RCCP) involves collecting geospatial data from multiple communities, each providing datasets in varying formats, structures, and levels of completeness. Manually processing these datasets—extracting ArcGIS packages, organizing content, creating database users, and loading data into an enterprise geodatabase—would be time-consuming, error-prone, and difficult to scale. The problem addressed in this project was how to design a fully automated workflow that could standardize incoming data, provision the necessary database infrastructure, and load datasets into an enterprise PostgreSQL geodatabase in a consistent and repeatable manner.
Analysis Procedures
This project consisted of developing a suite of Python scripts using ArcPy to automate the full data ingestion and database preparation process. The workflow began with a package extraction script, designed to process ArcGIS package formats (.mpk, .mpkx, .ppkx). The script recursively scanned input directories, extracted package contents, and organized them into a structured staging environment. During this process, datasets were evaluated, filtered, and prepared for import, ensuring that only valid feature classes and tables were retained. A second script focused on enterprise geodatabase provisioning. This script automated the creation of database users and schemas within PostgreSQL, assigning each community its own schema to support logical data separation. It also generated .sde connection files for each user, enabling secure and consistent access from both ArcGIS Pro and ArcGIS Server environments. Permissions were configured programmatically to ensure appropriate access control across the system. The third component of the workflow handled data migration into the enterprise geodatabase. This script iterated through the prepared datasets and copied feature classes and tables from local file geodatabases into the PostgreSQL-backed enterprise geodatabase. Data was organized by community schema, preserving structure while ensuring compatibility with enterprise workflows. The script also accounted for potential issues such as unsupported table types and inconsistencies in source data. Throughout the workflow, logging mechanisms were implemented to track processing steps, capture errors, and provide transparency into the execution of each script. This allowed the entire process to be repeatable, auditable, and adaptable to new datasets.
Results
The final solution produced a fully automated pipeline for transforming raw community-submitted data into enterprise-ready geospatial datasets. Tasks that would traditionally require extensive manual effort—such as extracting packages, creating database users, and loading data—were reduced to a streamlined, script-driven process. The system successfully created and configured PostgreSQL schemas, established secure database connections, and populated the enterprise geodatabase with standardized datasets. This enabled immediate use of the data for publishing web services and supporting downstream applications. By automating the ingestion and provisioning workflow, the project improved efficiency, reduced the likelihood of human error, and ensured consistency across multiple communities. The resulting system is scalable and can be reused for future data integration efforts with minimal modification.
Reflection
This project significantly strengthened my programming skills within a GIS context, particularly in developing scripts that interact with both geospatial data and enterprise database systems. It required not only familiarity with ArcPy, but also an understanding of how GIS workflows translate into automated processes. One of the most valuable aspects of this work was designing scripts that operate reliably across varied and imperfect input data. Handling edge cases, filtering unsupported data types, and ensuring that outputs were consistent required careful planning and iterative testing. The project also reinforced the importance of automation in enterprise GIS environments. By replacing manual workflows with scripted processes, the system becomes more efficient, reproducible, and easier to maintain. This experience highlighted how programming can be used to bridge the gap between data management and system-level GIS operations. Overall, this work reflects a shift from using Python for isolated tasks to developing integrated tools that support large-scale geospatial workflows.