diff --git a/configurations/default/server.yml.tmp b/configurations/default/server.yml.tmp
index 6d78c25cc..20edb3008 100644
--- a/configurations/default/server.yml.tmp
+++ b/configurations/default/server.yml.tmp
@@ -34,6 +34,28 @@ modules:
     load_on_fetch: false
     # use_extension: mtc
     # update_frequency: 30 # in seconds
+  manager:
+    normalizeFieldTransformation:
+      # Enter capitalization exceptions (e.g. acronyms), in the desired case, and separated by commas.
+      defaultCapitalizationExceptions:
+        - ACE
+        - BART
+      # Enter substitutions (e.g. substitute '@' with 'at'), one dashed entry for each substitution, with:
+      # - pattern: the regex string pattern that will be replaced,
+      # - replacement: the replacement string for that pattern,
+      # - normalizeSpace: if true, the resulting field value will include one space before and after the replacement string.
+      #       Note: if the replacement must be blank, then normalizeSpace should be set to false
+      #       and whitespace management should be handled in pattern instead.
+      # Substitutions are executed in order they appear in the list.
+      defaultSubstitutions:
+        - description: "Replace '@' with 'at', and normalize space."
+          pattern: "@"
+          replacement: at
+          normalizeSpace: true
+        - description: "Replace '+' (\\+ in regex) and '&' with 'and', and normalize space."
+          pattern: "[\\+&]"
+          replacement: and
+          normalizeSpace: true
 extensions:
   transitland:
     enabled: true
diff --git a/configurations/test/server.yml.tmp b/configurations/test/server.yml.tmp
index 951f4dd63..677eee64c 100644
--- a/configurations/test/server.yml.tmp
+++ b/configurations/test/server.yml.tmp
@@ -35,6 +35,39 @@ modules:
     load_on_fetch: false
     # use_extension: mtc
     # update_frequency: 30 # in seconds
+  manager:
+    normalizeFieldTransformation:
+      # Enter capitalization exceptions (e.g. acronyms), in the desired case, and separated by commas.
+      defaultCapitalizationExceptions:
+        - ACE
+        - BART
+        - SMART
+        - EB
+        - WB
+        - SB
+        - NB
+      # Enter substitutions (e.g. substitute '@' with 'at'), one dashed entry for each substitution, with:
+      # - pattern: the regex string pattern that will be replaced,
+      # - replacement: the replacement string for that pattern,
+      # - normalizeSpace: if true, the resulting field value will include one space before and after the replacement string.
+      #       Note: if the replacement must be blank, then normalizeSpace should be set to false
+      #       and whitespace management should be handled in pattern instead.
+      # Substitutions are executed in order they appear in the list.
+      defaultSubstitutions:
+        - description: "Replace '@' with 'at', and normalize space."
+          pattern: "@"
+          replacement: at
+          normalizeSpace: true
+        - description: "Replace '+' (\\+ in regex) and '&' with 'and, and normalize space."
+          pattern: "[\\+&]"
+          replacement: and
+          normalizeSpace: true
+        - description: "Remove content in parentheses and adjacent space outside the parentheses."
+          pattern: "\\s*\\(.+\\)\\s*"
+          replacement: ""
+        - description: "Remove content in square brackets and adjacent space outside the brackets."
+          pattern: "\\s*\\[.+\\]\\s*"
+          replacement: ""
 extensions:
   # Enable MTC extension so MTC-specific feed merge tests
   mtc:
diff --git a/pom.xml b/pom.xml
index 38ddb2de7..0a90ae2d1 100644
--- a/pom.xml
+++ b/pom.xml
@@ -39,7 +39,7 @@
         <url>https://github.com/ibi-group/datatools-server.git</url>
     </scm>
     <properties>
-        <jackson.version>2.10.1</jackson.version>
+        <jackson.version>2.12.1</jackson.version>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <!-- Using the latest version of geotools (e.g, 20) seems to cause issues with the shapefile
         plugin where the_geom for each feature is null. -->
@@ -255,6 +255,13 @@
             <version>5.7.0</version>
             <scope>test</scope>
         </dependency>
+        <!-- Provides JUnit 5.x parametrized tests -->
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-params</artifactId>
+            <version>5.5.2</version>
+            <scope>test</scope>
+        </dependency>
 
         <!-- Used for loading/fetching/validating/writing GTFS entities. gtfs-lib also provides access to:
          - commons-io - generic utilities
@@ -435,7 +442,6 @@
             <artifactId>aws-java-sdk-sts</artifactId>
             <version>${awsjavasdk.version}</version>
         </dependency>
-
     </dependencies>
 
 </project>
diff --git a/src/main/java/com/conveyal/datatools/common/status/MonitorableJob.java b/src/main/java/com/conveyal/datatools/common/status/MonitorableJob.java
index f2da60f03..d6551880d 100644
--- a/src/main/java/com/conveyal/datatools/common/status/MonitorableJob.java
+++ b/src/main/java/com/conveyal/datatools/common/status/MonitorableJob.java
@@ -288,7 +288,8 @@ private String getCallingMethodTrace() {
          * Shorthand method to update status object on successful job completion.
          */
         public void completeSuccessfully(String message) {
-            this.complete(false, message);
+            // Do not overwrite the message (and other fields), if the job has already been completed.
+            if (!this.completed) this.complete(false, message);
         }
 
         /**
@@ -296,7 +297,7 @@ public void completeSuccessfully(String message) {
          */
         private void complete(boolean isError, String message) {
             this.error = isError;
-            // Skip message update if null.
+            // Skip message update if the job message is null or the message has already been defined.
             if (message != null) this.message = message;
             this.percentComplete = 100;
             this.completed = true;
diff --git a/src/main/java/com/conveyal/datatools/manager/jobs/ArbitraryTransformJob.java b/src/main/java/com/conveyal/datatools/manager/jobs/ArbitraryTransformJob.java
index b501bd028..2a9be70e7 100644
--- a/src/main/java/com/conveyal/datatools/manager/jobs/ArbitraryTransformJob.java
+++ b/src/main/java/com/conveyal/datatools/manager/jobs/ArbitraryTransformJob.java
@@ -12,7 +12,7 @@
 /**
  * This job will apply a {@link ZipTransformation} or {@link DbTransformation} to a GTFS zip file or database namespace,
  * respectively, and generate the required FeedTransformTarget object from those inputs, which is passed into the
- * {@link FeedTransformation#transform} method.
+ * {@link FeedTransformation#doTransform} method.
  */
 public class ArbitraryTransformJob extends MonitorableJob {
 
@@ -43,6 +43,6 @@ public void jobLogic() {
         target.validate(status);
         if (status.error) return;
         // If target is valid, perform transformation.
-        transformation.transform(target, status);
+        transformation.doTransform(target, status);
     }
 }
diff --git a/src/main/java/com/conveyal/datatools/manager/models/transform/DbTransformation.java b/src/main/java/com/conveyal/datatools/manager/models/transform/DbTransformation.java
index eba3ebbf1..b39a7bedd 100644
--- a/src/main/java/com/conveyal/datatools/manager/models/transform/DbTransformation.java
+++ b/src/main/java/com/conveyal/datatools/manager/models/transform/DbTransformation.java
@@ -1,5 +1,8 @@
 package com.conveyal.datatools.manager.models.transform;
 
+import com.conveyal.datatools.common.status.MonitorableJob;
+import com.conveyal.gtfs.loader.JdbcGtfsLoader;
+
 import java.util.List;
 
 /**
@@ -7,7 +10,24 @@
  * words, subclasses will provide a transform override method that acts on a database namespace. Sample fields
  * matchField and matchValues can be used to construct a WHERE clause for applying updates to a filtered set of records.
  */
-public abstract class DbTransformation extends FeedTransformation {
+public abstract class DbTransformation extends FeedTransformation<FeedTransformDbTarget> {
     public String matchField;
     public List<String> matchValues;
+
+    protected String getTransformationTypeName() {
+        return FeedTransformDbTarget.class.getSimpleName();
+    }
+
+    protected void validateFieldNames(MonitorableJob.Status status) {
+        // Validate fields before running transform.
+
+        if (matchField == null) {
+            status.fail("Must provide valid match field");
+            return;
+        }
+        String cleanField = JdbcGtfsLoader.sanitize(matchField, null);
+        if (!matchField.equals(cleanField)) {
+            status.fail("Input match field contained disallowed special characters (only alphanumeric and underscores are permitted).");
+        }
+    }
 }
diff --git a/src/main/java/com/conveyal/datatools/manager/models/transform/DeleteRecordsTransformation.java b/src/main/java/com/conveyal/datatools/manager/models/transform/DeleteRecordsTransformation.java
index 955354142..05a0fc9d5 100644
--- a/src/main/java/com/conveyal/datatools/manager/models/transform/DeleteRecordsTransformation.java
+++ b/src/main/java/com/conveyal/datatools/manager/models/transform/DeleteRecordsTransformation.java
@@ -1,13 +1,9 @@
 package com.conveyal.datatools.manager.models.transform;
 
 import com.conveyal.datatools.common.status.MonitorableJob;
-import com.conveyal.datatools.manager.DataManager;
-import com.conveyal.datatools.manager.gtfsplus.tables.GtfsPlusTable;
 import com.conveyal.datatools.manager.models.Snapshot;
 import com.conveyal.datatools.manager.models.TableTransformResult;
 import com.conveyal.datatools.manager.persistence.Persistence;
-import com.conveyal.gtfs.loader.JdbcGtfsLoader;
-import com.conveyal.gtfs.loader.Table;
 import com.conveyal.gtfs.util.InvalidNamespaceException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -15,10 +11,8 @@
 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.SQLException;
-import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
-import java.util.stream.Collectors;
 
 import static com.conveyal.datatools.manager.DataManager.GTFS_DATA_SOURCE;
 import static com.conveyal.gtfs.util.Util.ensureValidNamespace;
@@ -43,13 +37,7 @@ public static DeleteRecordsTransformation create(String table, String matchField
     }
 
     @Override
-    public void transform(FeedTransformTarget target, MonitorableJob.Status status) {
-        if (!(target instanceof FeedTransformDbTarget)) {
-            status.fail("Target must be FeedTransformDbTarget.");
-            return;
-        }
-        // Cast transform target to DB flavor.
-        FeedTransformDbTarget dbTarget = (FeedTransformDbTarget)target;
+    public void transform(FeedTransformDbTarget dbTarget, MonitorableJob.Status status) {
         // Fetch the referenced snapshot to transform.
         Snapshot snapshot = Persistence.snapshots.getById(dbTarget.snapshotId);
         if (snapshot == null) {
@@ -57,36 +45,6 @@ public void transform(FeedTransformTarget target, MonitorableJob.Status status)
             return;
         }
 
-        // TODO: Move validation code into its own method?
-        final List<Table> tables =
-            Arrays.stream(Table.tablesInOrder)
-                .filter(Table::isSpecTable)
-                .collect(Collectors.toList());
-        if (DataManager.isModuleEnabled("gtfsplus")) {
-            // Add GTFS+ tables only if MTC extension is enabled.
-            tables.addAll(Arrays.asList(GtfsPlusTable.tables));
-        }
-        // Check that table name is valid (to prevent SQL injection).
-        Table matchingTable = null;
-        for (Table specTable : tables) {
-            if (specTable.name.equals(table)) {
-                matchingTable = specTable;
-                break;
-            }
-        }
-        if (matchingTable == null) {
-            status.fail("Table must be valid GTFS spec table name (without .txt).");
-            return;
-        }
-        if (matchField == null) {
-            status.fail("Must provide valid match field");
-            return;
-        }
-        String cleanField = JdbcGtfsLoader.sanitize(matchField, null);
-        if (!matchField.equals(cleanField)) {
-            status.fail("Input match field contained disallowed special characters (only alphanumeric and underscores are permitted).");
-            return;
-        }
         try {
             ensureValidNamespace(snapshot.namespace);
         } catch (InvalidNamespaceException e) {
@@ -111,9 +69,14 @@ public void transform(FeedTransformTarget target, MonitorableJob.Status status)
             int deleted = preparedStatement.executeUpdate();
             LOG.info("{} deleted {} records", this.getClass().getSimpleName(), deleted);
             connection.commit();
-            target.feedTransformResult.tableTransformResults.add(new TableTransformResult(table, deleted, 0, 0));
+            dbTarget.feedTransformResult.tableTransformResults.add(new TableTransformResult(table, deleted, 0, 0));
         } catch (SQLException e) {
             throw new RuntimeException(e);
         }
     }
+
+    @Override
+    public void validateParameters(MonitorableJob.Status status) {
+        // Does nothing.
+    }
 }
diff --git a/src/main/java/com/conveyal/datatools/manager/models/transform/FeedTransformation.java b/src/main/java/com/conveyal/datatools/manager/models/transform/FeedTransformation.java
index 8540e278a..0433fa457 100644
--- a/src/main/java/com/conveyal/datatools/manager/models/transform/FeedTransformation.java
+++ b/src/main/java/com/conveyal/datatools/manager/models/transform/FeedTransformation.java
@@ -1,6 +1,7 @@
 package com.conveyal.datatools.manager.models.transform;
 
 import com.conveyal.datatools.common.status.MonitorableJob;
+import com.conveyal.datatools.manager.utils.GtfsUtils;
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import com.fasterxml.jackson.annotation.JsonSubTypes;
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
@@ -8,7 +9,6 @@
 
 import java.io.Serializable;
 
-
 /**
  * This abstract class is the base for arbitrary feed transformations.
  *
@@ -28,10 +28,11 @@
 @JsonTypeInfo(use = JsonTypeInfo.Id.NAME)
 @JsonSubTypes({
     @JsonSubTypes.Type(value = DeleteRecordsTransformation.class, name = "DeleteRecordsTransformation"),
+    @JsonSubTypes.Type(value = NormalizeFieldTransformation.class, name = "NormalizeFieldTransformation"),
     @JsonSubTypes.Type(value = ReplaceFileFromVersionTransformation.class, name = "ReplaceFileFromVersionTransformation"),
     @JsonSubTypes.Type(value = ReplaceFileFromStringTransformation.class, name = "ReplaceFileFromStringTransformation")
 })
-public abstract class FeedTransformation implements Serializable {
+public abstract class FeedTransformation<Target extends FeedTransformTarget> implements Serializable {
     private static final long serialVersionUID = 1L;
     public String table;
     public boolean active = true;
@@ -46,5 +47,58 @@ public boolean isActive() {
     //  it could return something object that contains a bool + message.
     // boolean isValid();
 
-    public abstract void transform(FeedTransformTarget target, MonitorableJob.Status status);
+    public void doTransform(FeedTransformTarget target, MonitorableJob.Status status) {
+        try {
+            // Attempt to cast transform target to correct flavor
+            // (fails the job if types mismatch.)
+            Target typedTarget = (Target)target;
+
+            // Validate parameters before running transform.
+            validateTableName(status);
+            validateFieldNames(status);
+            // Let subclasses check parameters.
+            validateParameters(status);
+            if (status.error) {
+                return;
+            }
+
+            // Pass the typed transform target to subclasses to transform.
+            transform(typedTarget, status);
+        } catch (ClassCastException classCastException) {
+            status.fail(
+                String.format("Transformation must be of type '%s'.", getTransformationTypeName())
+            );
+        }
+    }
+
+    protected abstract String getTransformationTypeName();
+
+    /**
+     * Contains the logic for this database-bound transformation.
+     * @param target The database-bound or ZIP-file-bound target the transformation will operate on.
+     * @param status Used to report success or failure status and details.
+     */
+    public abstract void transform(Target target, MonitorableJob.Status status);
+
+    /**
+     * At the moment, used by DbTransformation to validate field names.
+     */
+    protected abstract void validateFieldNames(MonitorableJob.Status status);
+
+    /**
+     * Handles validation logic prior to performing the transformation.
+     * Calling status.fail prevents the transform logic from running.
+     */
+    public abstract void validateParameters(MonitorableJob.Status status);
+
+    /**
+     * Checks that the table name for the transform is valid.
+     */
+    protected void validateTableName(MonitorableJob.Status status) {
+        // Validate fields before running transform.
+        if (GtfsUtils.getGtfsTable(table) == null) {
+            status.fail("Table must be valid GTFS spec table name (without .txt).");
+            return;
+        }
+    }
 }
diff --git a/src/main/java/com/conveyal/datatools/manager/models/transform/NormalizeFieldTransformation.java b/src/main/java/com/conveyal/datatools/manager/models/transform/NormalizeFieldTransformation.java
new file mode 100644
index 000000000..ebb24b7f7
--- /dev/null
+++ b/src/main/java/com/conveyal/datatools/manager/models/transform/NormalizeFieldTransformation.java
@@ -0,0 +1,259 @@
+package com.conveyal.datatools.manager.models.transform;
+
+import com.conveyal.datatools.common.status.MonitorableJob;
+import com.conveyal.datatools.manager.models.TableTransformResult;
+import com.conveyal.datatools.manager.utils.GtfsUtils;
+import com.conveyal.datatools.manager.utils.json.JsonUtil;
+import com.conveyal.gtfs.loader.Field;
+import com.conveyal.gtfs.loader.Table;
+import com.csvreader.CsvReader;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.text.WordUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.supercsv.io.CsvListWriter;
+import org.supercsv.prefs.CsvPreference;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.io.StringWriter;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.FileSystem;
+import java.nio.file.FileSystems;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardCopyOption;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.zip.ZipFile;
+
+import static com.conveyal.datatools.manager.DataManager.getConfigProperty;
+import static com.conveyal.gtfs.loader.Field.getFieldIndex;
+
+/**
+ * This transformation normalizes string values for a given field in a GTFS table by:
+ * - changing the case of field values,
+ * - substituting certain strings with others.
+ * Exceptions to capitalization and substitutions are configurable application-wide in env.yml
+ * or for each transform individually using datatools-ui.
+ */
+public class NormalizeFieldTransformation extends ZipTransformation {
+    /**
+     * Different capitalization styles to apply.
+     */
+    public enum CapitalizationStyle {
+        TITLE_CASE
+    }
+
+    private static final Logger LOG = LoggerFactory.getLogger(NormalizeFieldTransformation.class);
+    public static final String CAPITALIZATION_EXCEPTIONS_CONFIG_PATH = "modules.manager.normalizeFieldTransformation.defaultCapitalizationExceptions";
+    public static final String SUBSTITUTION_CONFIG_PATH = "modules.manager.normalizeFieldTransformation.defaultSubstitutions";
+
+    private static final List<String> DEFAULT_CAPITALIZATION_EXCEPTIONS = JsonUtil.getPOJOFromJSONAsList(
+        getConfigProperty(CAPITALIZATION_EXCEPTIONS_CONFIG_PATH),
+        String.class
+    );
+    private static final List<Substitution> DEFAULT_SUBSTITUTIONS = JsonUtil.getPOJOFromJSONAsList(
+        getConfigProperty(SUBSTITUTION_CONFIG_PATH),
+        Substitution.class
+    );
+    // Common separator characters found on the US-English keyboard.
+    private static final char[] SEPARATORS = " \t\n`~!@#$%^&*()-_=+[{]}\\|;:'\",<.>/?".toCharArray();
+
+    /** The field name in the GTFS table being transformed. */
+    public String fieldName;
+
+    /** Whether to perform capitalization. */
+    public boolean capitalize = true;
+
+    /** Capitalization style, e.g. title case or sentence case. */
+    public CapitalizationStyle capitalizationStyle = CapitalizationStyle.TITLE_CASE;
+
+    /**
+     * Capitalization exceptions is for text that should remain as specified
+     * in the default capitalization exceptions or in the UI.
+     * (e.g., acronyms remain in uppercase, particles such as 'de' remain in lowercase.)
+     */
+    public List<String> capitalizationExceptions = DEFAULT_CAPITALIZATION_EXCEPTIONS;
+
+    /**
+     * Substitutions are initialized with the default configured ones,
+     * and can be overridden from the UI. This list can be empty.
+     */
+    public List<Substitution> substitutions = DEFAULT_SUBSTITUTIONS;
+
+    // This field is reset when the setter is called
+    // and initialized when executing the transform method.
+    private List<Substitution> capitalizationSubstitutions;
+
+    private List<Substitution> getCapitalizationSubstitutions() {
+        if (capitalizationSubstitutions == null) {
+            initializeCapitalizeSubstitutions();
+        }
+        return capitalizationSubstitutions;
+    }
+
+    /**
+     * Used in tests to create an instance of this transform.
+     * @param table The table with the field to modify.
+     * @param fieldName The field in the specified table to modify.
+     * @param exceptions A list of capitalization exceptions:
+     *                   - if null, the default configured exceptions will be used.
+     *                   - if empty, no capitalization exceptions will be considered.
+     * @param substitutions A list of substitutions:
+     *                      - if null, the default configured substitutions will be performed.
+     *                      - if empty, no substitutions will be performed.
+     * @return An instance of the transformation with the desired settings.
+     */
+    static NormalizeFieldTransformation create(
+        String table, String fieldName, List<String> exceptions, List<Substitution> substitutions)
+    {
+        NormalizeFieldTransformation transformation = new NormalizeFieldTransformation();
+        transformation.fieldName = fieldName;
+        transformation.table = table;
+        // Override configured defaults if corresponding args are not null.
+        // (To set up no capitalization exceptions or no substitutions, pass an empty string.)
+        if (exceptions != null) {
+            transformation.capitalizationExceptions = exceptions;
+        }
+        if (substitutions != null) {
+            transformation.substitutions = substitutions;
+        }
+        return transformation;
+    }
+
+    /**
+     * Initializes capitalizeSubstitutions so that it is a non-null list.
+     */
+    private void initializeCapitalizeSubstitutions() {
+        capitalizationSubstitutions = capitalizationExceptions == null
+            ? new ArrayList<>()
+            : capitalizationExceptions.stream()
+                .map(word -> new Substitution(
+                    // TODO: support other capitalization styles.
+                    String.format("\\b%s\\b", WordUtils.capitalizeFully(word)),
+                    word
+                ))
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public void validateParameters(MonitorableJob.Status status) {
+        if (fieldName == null) {
+            status.fail("Field name must not be null");
+        }
+    }
+
+    @Override
+    public void transform(FeedTransformZipTarget zipTarget, MonitorableJob.Status status) {
+        String tableName = table + ".txt";
+        try(
+            // Hold output before writing to ZIP
+            StringWriter stringWriter = new StringWriter();
+            // CSV writer used to write to zip file.
+            CsvListWriter writer = new CsvListWriter(stringWriter, CsvPreference.STANDARD_PREFERENCE)
+        ) {
+            Path tempZipPath = Files.createTempFile("field-normalization", ".zip");
+            Path originalZipPath = Paths.get(zipTarget.gtfsFile.getAbsolutePath());
+
+            // Create a temporary working zip file from original.
+            Files.copy(originalZipPath, tempZipPath, StandardCopyOption.REPLACE_EXISTING);
+
+            Table gtfsTable = GtfsUtils.getGtfsTable(table);
+            CsvReader csvReader = gtfsTable.getCsvReader(new ZipFile(tempZipPath.toAbsolutePath().toString()), null);
+            final String[] headers = csvReader.getHeaders();
+            Field[] fieldsFoundInZip = gtfsTable.getFieldsFromFieldHeaders(headers, null);
+            int transformFieldIndex = getFieldIndex(fieldsFoundInZip, fieldName);
+
+            int modifiedRowCount = 0;
+
+            // Write headers and processed CSV rows.
+            writer.write(headers);
+            while (csvReader.readRecord()) {
+                String originalValue = csvReader.get(transformFieldIndex);
+                String transformedValue = originalValue;
+
+                // Convert to title case, if requested.
+                if (capitalize) {
+                    if (capitalizationStyle == CapitalizationStyle.TITLE_CASE) {
+                        transformedValue = convertToTitleCase(transformedValue);
+                    }
+                    // TODO: Implement other capitalization styles.
+                }
+
+                // Perform substitutions if any.
+                transformedValue = performSubstitutions(transformedValue);
+
+                // Re-assemble the CSV line and place in buffer.
+                String[] csvValues = csvReader.getValues();
+                csvValues[transformFieldIndex] = transformedValue;
+
+                // Write line to table (plus new line char).
+                writer.write(csvValues);
+
+                // Count number of CSV rows changed.
+                if (!originalValue.equals(transformedValue)) {
+                    modifiedRowCount++;
+                }
+            } // End of iteration over each row.
+            csvReader.close();
+            writer.flush();
+
+            // Copy csv input stream into the zip file, replacing the existing file.
+            try (
+                // Modify target zip file that we just read.
+                FileSystem targetZipFs = FileSystems.newFileSystem(tempZipPath, null);
+                // Stream for file copy operation.
+                InputStream inputStream =  new ByteArrayInputStream(stringWriter.toString().getBytes(StandardCharsets.UTF_8))
+            ) {
+                Path targetTxtFilePath = getTablePathInZip(tableName, targetZipFs);
+                Files.copy(inputStream, targetTxtFilePath, StandardCopyOption.REPLACE_EXISTING);
+                zipTarget.feedTransformResult.tableTransformResults.add(
+                    new TableTransformResult(tableName, 0, modifiedRowCount, 0)
+                );
+            }
+
+            // Replace original zip file with temporary working zip file.
+            // (This should also trigger a system IO update event, so subsequent IO calls pick up the correct file.
+            Files.move(tempZipPath, originalZipPath, StandardCopyOption.REPLACE_EXISTING);
+            LOG.info("Field normalization transformation successful, {} row(s) changed.", modifiedRowCount);
+        } catch (Exception e) {
+            status.fail("Unknown error encountered while transforming zip file", e);
+        }
+    }
+
+    /**
+     * Converts the provided string to Title Case, accommodating for capitalization exceptions
+     * and separator characters that may be immediately precede
+     * (without spaces) text that we need to capitalize.
+     */
+    public String convertToTitleCase(String inputString) {
+        // Return at least a blank string.
+        if (StringUtils.isBlank(inputString)) {
+            return "";
+        }
+
+        String result = WordUtils.capitalizeFully(inputString, SEPARATORS);
+
+        // Exceptions should remain as specified (e.g. acronyms).
+        for (Substitution substitution : getCapitalizationSubstitutions()) {
+            result = substitution.replaceAll(result);
+        }
+
+        return result;
+    }
+
+    /**
+     * Performs substitutions defined for this transform, and returns the result.
+     */
+    public String performSubstitutions(String inputString) {
+        if (substitutions == null) return inputString;
+        String result = inputString;
+        for (Substitution substitution : substitutions) {
+            result = substitution.replaceAll(result);
+        }
+        return result;
+    }
+}
diff --git a/src/main/java/com/conveyal/datatools/manager/models/transform/ReplaceFileFromStringTransformation.java b/src/main/java/com/conveyal/datatools/manager/models/transform/ReplaceFileFromStringTransformation.java
index 3b71ee2e6..5673d0c05 100644
--- a/src/main/java/com/conveyal/datatools/manager/models/transform/ReplaceFileFromStringTransformation.java
+++ b/src/main/java/com/conveyal/datatools/manager/models/transform/ReplaceFileFromStringTransformation.java
@@ -27,37 +27,32 @@ public static ReplaceFileFromStringTransformation create(String csvData, String
     }
 
     @Override
-    public void transform(FeedTransformTarget target, MonitorableJob.Status status) {
-        if (!(target instanceof FeedTransformZipTarget)) {
-            status.fail("Target must be FeedTransformZipTarget.");
-            return;
-        }
-        // Cast transform target to zip flavor.
-        FeedTransformZipTarget zipTarget = (FeedTransformZipTarget)target;
+    public void validateParameters(MonitorableJob.Status status) {
         if (csvData == null) {
-            // TODO: If this is a null value, delete the table (not yet supported).
             status.fail("CSV data must not be null (delete table not yet supported)");
-            return;
-        }
-        if (table == null) {
-            status.fail("Must specify transformation table name.");
-            return;
         }
+    }
+
+    @Override
+    public void transform(FeedTransformZipTarget zipTarget, MonitorableJob.Status status) {
+        // if (csvData == null) {
+        //     TODO: If this is a null value, delete the table (not yet supported).
+        // }
+
         String tableName = table + ".txt";
-        String tableNamePath = "/" + tableName;
         // Run the replace transformation
         Path targetZipPath = Paths.get(zipTarget.gtfsFile.getAbsolutePath());
         try( FileSystem targetZipFs = FileSystems.newFileSystem(targetZipPath, null) ){
             // Convert csv data to input stream.
             InputStream inputStream = new ByteArrayInputStream(csvData.getBytes(StandardCharsets.UTF_8));
-            Path targetTxtFilePath = targetZipFs.getPath(tableNamePath);
+            Path targetTxtFilePath = getTablePathInZip(tableName, targetZipFs);
             // Set transform type according to whether target file exists.
             TransformType type = Files.exists(targetTxtFilePath)
                 ? TransformType.TABLE_REPLACED
                 : TransformType.TABLE_ADDED;
             // Copy csv input stream into the zip file, replacing it if it already exists.
             Files.copy(inputStream, targetTxtFilePath, StandardCopyOption.REPLACE_EXISTING);
-            target.feedTransformResult.tableTransformResults.add(new TableTransformResult(tableName, type));
+            zipTarget.feedTransformResult.tableTransformResults.add(new TableTransformResult(tableName, type));
         } catch (Exception e) {
             status.fail("Unknown error encountered while transforming zip file", e);
         }
diff --git a/src/main/java/com/conveyal/datatools/manager/models/transform/ReplaceFileFromVersionTransformation.java b/src/main/java/com/conveyal/datatools/manager/models/transform/ReplaceFileFromVersionTransformation.java
index 84f9d58ca..e78d21f72 100644
--- a/src/main/java/com/conveyal/datatools/manager/models/transform/ReplaceFileFromVersionTransformation.java
+++ b/src/main/java/com/conveyal/datatools/manager/models/transform/ReplaceFileFromVersionTransformation.java
@@ -33,41 +33,32 @@ public static ReplaceFileFromVersionTransformation create(String sourceVersionId
     }
 
     @Override
-    public void transform(FeedTransformTarget target, MonitorableJob.Status status) {
-        if (!(target instanceof FeedTransformZipTarget)) {
-            status.fail("Target must be FeedTransformZipTarget.");
-            return;
-        }
-        // Cast transform target to zip flavor.
-        FeedTransformZipTarget zipTarget = (FeedTransformZipTarget)target;
-        FeedVersion sourceVersion = Persistence.feedVersions.getById(sourceVersionId);
-        if (sourceVersion == null) {
+    public void validateParameters(MonitorableJob.Status status) {
+        if (getSourceVersion() == null) {
             status.fail("Source version ID must reference valid version.");
-            return;
-        }
-        if (table == null) {
-            status.fail("Must specify transformation table name.");
-            return;
         }
-        String tableName = table + ".txt";
-        String tableNamePath = "/" + tableName;
+    }
 
+    @Override
+    public void transform(FeedTransformZipTarget zipTarget, MonitorableJob.Status status) {
+        FeedVersion sourceVersion = getSourceVersion();
+        String tableName = table + ".txt";
         // Run the replace transformation
         Path sourceZipPath = Paths.get(sourceVersion.retrieveGtfsFile().getAbsolutePath());
         try (FileSystem sourceZipFs = FileSystems.newFileSystem(sourceZipPath, null)) {
             // If the source txt file does not exist, NoSuchFileException will be thrown and caught below.
-            Path sourceTxtFilePath = sourceZipFs.getPath(tableNamePath);
+            Path sourceTxtFilePath = getTablePathInZip(tableName, sourceZipFs);
             Path targetZipPath = Paths.get(zipTarget.gtfsFile.getAbsolutePath());
-            LOG.info("Replacing file {} in zip file {} with source {}", tableNamePath, targetZipPath.getFileName(), sourceVersion.id);
+            LOG.info("Replacing file {} in zip file {} with source {}", tableName, targetZipPath.getFileName(), sourceVersion.id);
             try (FileSystem targetZipFs = FileSystems.newFileSystem(targetZipPath, null)) {
-                Path targetTxtFilePath = targetZipFs.getPath(tableNamePath);
+                Path targetTxtFilePath = getTablePathInZip(tableName, targetZipFs);
                 // Set transform type according to whether target file exists.
                 TransformType type = Files.exists(targetTxtFilePath)
                     ? TransformType.TABLE_REPLACED
                     : TransformType.TABLE_ADDED;
                 // Copy a file into the zip file, replacing it if it already exists.
                 Files.copy(sourceTxtFilePath, targetTxtFilePath, StandardCopyOption.REPLACE_EXISTING);
-                target.feedTransformResult.tableTransformResults.add(new TableTransformResult(tableName, type));
+                zipTarget.feedTransformResult.tableTransformResults.add(new TableTransformResult(tableName, type));
             }
             LOG.info("File replacement zip transformation successful!");
         } catch (NoSuchFileException e) {
@@ -76,4 +67,8 @@ public void transform(FeedTransformTarget target, MonitorableJob.Status status)
             status.fail("Unknown error encountered while transforming zip file", e);
         }
     }
+
+    private FeedVersion getSourceVersion() {
+        return Persistence.feedVersions.getById(sourceVersionId);
+    }
 }
diff --git a/src/main/java/com/conveyal/datatools/manager/models/transform/Substitution.java b/src/main/java/com/conveyal/datatools/manager/models/transform/Substitution.java
new file mode 100644
index 000000000..5a7f2db07
--- /dev/null
+++ b/src/main/java/com/conveyal/datatools/manager/models/transform/Substitution.java
@@ -0,0 +1,68 @@
+package com.conveyal.datatools.manager.models.transform;
+
+import java.io.Serializable;
+import java.util.regex.Pattern;
+
+/**
+ * This class holds the regex/replacement pair, and the cached compiled regex pattern.
+ */
+public class Substitution implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    /** Free-form text that describes the substitution. */
+    public String description;
+    /** The regex pattern string to match. */
+    public String pattern;
+    /** The string that should replace regex (see effectiveReplacement below). */
+    public String replacement;
+    /** true if whitespace surrounding regex should be create or normalized to one space. */
+    public boolean normalizeSpace;
+
+    private Pattern patternObject;
+    /**
+     * Replacement string that is actually used for the substitution,
+     * and set according to the value of normalizeSpace.
+     */
+    private String effectiveReplacement;
+
+    /** Empty constructor needed for persistence */
+    public Substitution() {}
+
+    public Substitution(String pattern, String replacement) {
+        this(pattern, replacement, false);
+    }
+
+    public Substitution(String pattern, String replacement, boolean normalizeSpace) {
+        this.pattern = pattern;
+        this.normalizeSpace = normalizeSpace;
+        this.replacement = replacement;
+    }
+
+    /**
+     * Pre-compiles the regex pattern and determines the actual replacement string
+     * according to normalizeSpace.
+     */
+    private void initialize() {
+        if (normalizeSpace) {
+            // If normalizeSpace is set, reduce spaces before and after the regex to one space,
+            // or insert one space before and one space after if there is none.
+            // Note: if the replacement must be blank, then normalizeSpace should be set to false
+            // and whitespace management should be handled in the regex instead.
+            this.patternObject = Pattern.compile(String.format("\\s*%s\\s*", pattern));
+            this.effectiveReplacement = String.format(" %s ", replacement);
+        } else {
+            this.patternObject = Pattern.compile(pattern);
+            this.effectiveReplacement = replacement;
+        }
+    }
+
+    /**
+     * Perform the replacement of regex in the provided string, and return the result.
+     */
+    public String replaceAll(String input) {
+        if (patternObject == null) {
+            initialize();
+        }
+        return patternObject.matcher(input).replaceAll(effectiveReplacement);
+    }
+}
diff --git a/src/main/java/com/conveyal/datatools/manager/models/transform/ZipTransformation.java b/src/main/java/com/conveyal/datatools/manager/models/transform/ZipTransformation.java
index eba369b16..6581a2704 100644
--- a/src/main/java/com/conveyal/datatools/manager/models/transform/ZipTransformation.java
+++ b/src/main/java/com/conveyal/datatools/manager/models/transform/ZipTransformation.java
@@ -1,12 +1,32 @@
 package com.conveyal.datatools.manager.models.transform;
 
+import com.conveyal.datatools.common.status.MonitorableJob;
+
+import java.nio.file.FileSystem;
+import java.nio.file.Path;
+
 /**
  * This is an abstract class that represents a transformation that should apply to a GTFS in zip form. In other
  * words, subclasses will provide a transform override method that acts directly on the zip file. Sample fields
  * csvData and sourceVersionId can be used to reference replacement string or file that should be passed to the target
  * zip file of the transformation.
  */
-public abstract class ZipTransformation extends FeedTransformation {
+public abstract class ZipTransformation extends FeedTransformation<FeedTransformZipTarget> {
     public String csvData;
     public String sourceVersionId;
+
+    protected void validateFieldNames(MonitorableJob.Status status) {
+        // Do nothing.
+    }
+
+    protected String getTransformationTypeName() {
+        return FeedTransformZipTarget.class.getSimpleName();
+    }
+
+    /**
+     * Obtains a {@link Path} object for the specified GTFS table file in a ZIP archive.
+     */
+    protected Path getTablePathInZip(String tableName, FileSystem targetZipFs) {
+        return targetZipFs.getPath("/" + tableName);
+    }
 }
diff --git a/src/main/java/com/conveyal/datatools/manager/utils/GtfsUtils.java b/src/main/java/com/conveyal/datatools/manager/utils/GtfsUtils.java
new file mode 100644
index 000000000..3f7f2d7cb
--- /dev/null
+++ b/src/main/java/com/conveyal/datatools/manager/utils/GtfsUtils.java
@@ -0,0 +1,37 @@
+package com.conveyal.datatools.manager.utils;
+
+import com.conveyal.datatools.manager.DataManager;
+import com.conveyal.datatools.manager.gtfsplus.tables.GtfsPlusTable;
+import com.conveyal.gtfs.loader.Table;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * Utility class dealing with GTFS tables.
+ */
+public class GtfsUtils {
+    /**
+     * Obtains a GTFS table.
+     * @param tableName The name of the table to obtain (e.g. "agency.txt").
+     * @return
+     */
+    public static Table getGtfsTable(String tableName) {
+        final List<Table> tables = Arrays.stream(Table.tablesInOrder)
+            .filter(Table::isSpecTable)
+            .collect(Collectors.toList());
+        if (DataManager.isModuleEnabled("gtfsplus")) {
+            // Add GTFS+ tables only if MTC extension is enabled.
+            tables.addAll(Arrays.asList(GtfsPlusTable.tables));
+        }
+        // Check that table name is valid (to prevent SQL injection).
+        for (Table specTable : tables) {
+            if (specTable.name.equals(tableName)) {
+                return specTable;
+            }
+        }
+
+        return null;
+    }
+}
diff --git a/src/main/java/com/conveyal/datatools/manager/utils/json/JsonUtil.java b/src/main/java/com/conveyal/datatools/manager/utils/json/JsonUtil.java
index 77f221612..5bbd2ca19 100644
--- a/src/main/java/com/conveyal/datatools/manager/utils/json/JsonUtil.java
+++ b/src/main/java/com/conveyal/datatools/manager/utils/json/JsonUtil.java
@@ -4,6 +4,8 @@
 import com.fasterxml.jackson.databind.JavaType;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.ObjectReader;
+import com.fasterxml.jackson.databind.type.CollectionType;
 import spark.Request;
 
 import java.io.IOException;
@@ -51,6 +53,22 @@ public static <T> List<T> getPOJOFromJSONAsList(Request req, String json, Class<
         }
     }
 
+    /**
+     * Utility method to parse generic objects from {@link JsonNode} and return as list
+     */
+    public static <T> List<T> getPOJOFromJSONAsList(JsonNode json, Class<T> clazz) {
+        if (json != null) {
+            CollectionType type = objectMapper.getTypeFactory().constructCollectionType(List.class, clazz);
+            ObjectReader reader = objectMapper.readerFor(type);
+            try {
+                return reader.readValue(json);
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return null;
+    }
+
     /**
      * Serialize an object into a JSON string representation.
      */
diff --git a/src/test/java/com/conveyal/datatools/DatatoolsTest.java b/src/test/java/com/conveyal/datatools/DatatoolsTest.java
index 09a369fed..6b28af131 100644
--- a/src/test/java/com/conveyal/datatools/DatatoolsTest.java
+++ b/src/test/java/com/conveyal/datatools/DatatoolsTest.java
@@ -48,6 +48,18 @@ public static void setUp() throws RuntimeException, IOException {
             }
         }
 
+        // If NOT in the e2e environment, ensure that /tmp/gtfsplus folder exists
+        // (otherwise some unit tests will be skipped).
+        if (!TestUtils.isRunningE2E()) {
+            File f = new File("/tmp/gtfsplus");
+            if (f.exists() && !f.isDirectory()) {
+                f.delete();
+            }
+            if (!f.exists()) {
+                f.mkdirs();
+            }
+        }
+
         LOG.info("Starting server");
         try {
             DataManager.main(args);
diff --git a/src/test/java/com/conveyal/datatools/manager/jobs/NormalizeFieldTransformJobTest.java b/src/test/java/com/conveyal/datatools/manager/jobs/NormalizeFieldTransformJobTest.java
new file mode 100644
index 000000000..004c21e3f
--- /dev/null
+++ b/src/test/java/com/conveyal/datatools/manager/jobs/NormalizeFieldTransformJobTest.java
@@ -0,0 +1,130 @@
+package com.conveyal.datatools.manager.jobs;
+
+import com.conveyal.datatools.DatatoolsTest;
+import com.conveyal.datatools.manager.models.FeedRetrievalMethod;
+import com.conveyal.datatools.manager.models.FeedSource;
+import com.conveyal.datatools.manager.models.FeedVersion;
+import com.conveyal.datatools.manager.models.Project;
+import com.conveyal.datatools.manager.models.transform.FeedTransformRules;
+import com.conveyal.datatools.manager.models.transform.FeedTransformation;
+import com.conveyal.datatools.manager.models.transform.NormalizeFieldTransformation;
+import com.conveyal.datatools.manager.models.transform.NormalizeFieldTransformationTest;
+import com.conveyal.datatools.manager.models.transform.Substitution;
+import com.conveyal.datatools.manager.persistence.Persistence;
+import com.google.common.collect.Lists;
+import org.apache.commons.lang3.ArrayUtils;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.Date;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+import static com.conveyal.datatools.TestUtils.createFeedVersion;
+import static com.conveyal.datatools.TestUtils.zipFolderFiles;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+
+public class NormalizeFieldTransformJobTest extends DatatoolsTest {
+    private static final String TABLE_NAME = "routes";
+    private static final String FIELD_NAME = "route_long_name";
+    private static Project project;
+    private static FeedSource feedSource;
+    private FeedVersion targetVersion;
+
+
+    /**
+     * Initialize Data Tools and set up a simple feed source and project.
+     */
+    @BeforeAll
+    public static void setUp() throws IOException {
+        // start server if it isn't already running
+        DatatoolsTest.setUp();
+
+        // Create a project.
+        project = createProject();
+
+        // Create transform.
+        // In this test class, as an illustration, we replace "Route" with the "Rte" abbreviation in routes.txt.
+        FeedTransformation transformation = NormalizeFieldTransformationTest.createTransformation(
+            TABLE_NAME, FIELD_NAME, null, Lists.newArrayList(
+                new Substitution("Route", "Rte")
+            )
+        );
+        FeedTransformRules transformRules = new FeedTransformRules(transformation);
+
+        // Create feed source with above transform.
+        feedSource = new FeedSource("Normalize Field Test Feed", project.id, FeedRetrievalMethod.MANUALLY_UPLOADED);
+        feedSource.deployable = false;
+        feedSource.transformRules.add(transformRules);
+        Persistence.feedSources.create(feedSource);
+    }
+
+    /**
+     * Clean up test database after tests finish.
+     */
+    @AfterAll
+    public static void tearDown() {
+        // Project delete cascades to feed sources.
+        project.delete();
+    }
+
+    /**
+     * Run tear down after each test. This just deletes the feed versions that were used in the test.
+     */
+    @AfterEach
+    public void tearDownTest() {
+        // Clean up
+        if (targetVersion != null) targetVersion.delete();
+    }
+
+    /**
+     * Test that a {@link NormalizeFieldTransformation} will successfully complete.
+     * FIXME: On certain Windows machines, this test fails.
+     */
+    @Test
+    public void canNormalizeField() throws IOException {
+        // Create target version that the transform will operate on.
+        targetVersion = createFeedVersion(
+            feedSource,
+            zipFolderFiles("fake-agency-with-only-calendar")
+        );
+
+        try (ZipFile zip = new ZipFile(targetVersion.retrieveGtfsFile())) {
+            // Check that new version has routes table modified.
+            ZipEntry entry = zip.getEntry(TABLE_NAME + ".txt");
+            assertNotNull(entry);
+
+            // Scan the first data row in routes.txt and check that the substitution
+            // that was defined in setUp was done.
+            try (
+                InputStream stream = zip.getInputStream(entry);
+                InputStreamReader streamReader = new InputStreamReader(stream);
+                BufferedReader reader = new BufferedReader(streamReader)
+            ) {
+                String[] columns = reader.readLine().split(",");
+                int fieldIndex = ArrayUtils.indexOf(columns, FIELD_NAME);
+
+                String row1 = reader.readLine();
+                String[] row1Fields = row1.split(",");
+                assertTrue(row1Fields[fieldIndex].startsWith("Rte "), row1);
+            }
+        }
+    }
+
+    // FIXME: Refactor (almost same code as AutoDeployJobTest in PR #361,
+    //        and some common code with PersistenceTest#createProject).
+    private static Project createProject() {
+        Project project = new Project();
+        project.name = String.format("Test Project %s", new Date().toString());
+        Persistence.projects.create(project);
+        return project;
+    }
+}
diff --git a/src/test/java/com/conveyal/datatools/manager/models/transform/NormalizeFieldTransformationTest.java b/src/test/java/com/conveyal/datatools/manager/models/transform/NormalizeFieldTransformationTest.java
new file mode 100644
index 000000000..0ab417ddb
--- /dev/null
+++ b/src/test/java/com/conveyal/datatools/manager/models/transform/NormalizeFieldTransformationTest.java
@@ -0,0 +1,126 @@
+package com.conveyal.datatools.manager.models.transform;
+
+import com.conveyal.datatools.DatatoolsTest;
+import com.conveyal.datatools.UnitTest;
+import com.google.common.collect.Lists;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class NormalizeFieldTransformationTest extends UnitTest {
+    @BeforeAll
+    public static void setUp() throws IOException {
+        // start server if it isn't already running
+        DatatoolsTest.setUp();
+    }
+
+    @ParameterizedTest
+    @MethodSource("createCapitalizationCases")
+    public void testConvertToTitleCase(String input, String expected) {
+        NormalizeFieldTransformation transform = createTransformation();
+        assertEquals(expected, transform.convertToTitleCase(input));
+    }
+
+    private static Stream<Arguments> createCapitalizationCases() {
+        return Stream.of(
+            Arguments.of(null, ""),
+            Arguments.of("LATHROP/MANTECA STATION", "Lathrop/Manteca Station"),
+            Arguments.of("12TH@WEST", "12th@West"),
+            Arguments.of("12TH+WEST", "12th+West"),
+            Arguments.of("12TH&WEST", "12th&West"),
+            Arguments.of("904 OCEANA BLVD-GOOD SHEPHERD SCHOOL", "904 Oceana Blvd-Good Shepherd School"),
+            // Capitalization exceptions from config (found on MTC Livermore Route 1)
+            Arguments.of("EAST DUBLIN BART STATION", "East Dublin BART Station"),
+            Arguments.of("DUBLIN & ARNOLD EB", "Dublin & Arnold EB")
+        );
+    }
+
+    @ParameterizedTest
+    @MethodSource("createCapitalizationCasesWithCustomExceptions")
+    public void testConvertToTitleCaseWithCustomExceptions(String input, String expected) {
+        NormalizeFieldTransformation transform = createTransformation(
+            "table", "field",  Lists.newArrayList("NE", "SW", "de"), null);
+        assertEquals(expected, transform.convertToTitleCase(input));
+    }
+
+    private static Stream<Arguments> createCapitalizationCasesWithCustomExceptions() {
+        return Stream.of(
+            // Capitalization exceptions from instance (quadrant street names)
+            Arguments.of("10TH STREET NE", "10th Street NE"),
+            Arguments.of("10TH STREET SW", "10th Street SW"),
+            // In the example below, particle 'de' should remain in lower case.
+            Arguments.of("PONCE DE LEON", "Ponce de Leon")
+        );
+    }
+
+    @ParameterizedTest
+    @MethodSource("createSubstitutionCases")
+    public void testPerformSubstitutions(String input, String expected) {
+        NormalizeFieldTransformation transform = createTransformation();
+        assertEquals(expected, transform.performSubstitutions(input));
+    }
+
+    private static Stream<Arguments> createSubstitutionCases() {
+        return Stream.of(
+            // Replace "@"
+            Arguments.of("12TH@WEST", "12TH at WEST"),
+            Arguments.of("12TH  @   WEST", "12TH at WEST"),
+            // Replace "+"
+            Arguments.of("12TH+WEST", "12TH and WEST"),
+            Arguments.of("12TH  +   WEST", "12TH and WEST"),
+            // Replace "&"
+            Arguments.of("12TH&WEST", "12TH and WEST"),
+            Arguments.of("12TH  &   WEST", "12TH and WEST"),
+            // Replace contents in parentheses and surrounding whitespace.
+            Arguments.of("14th St & Broadway (12th St BART) ", "14th St and Broadway")
+        );
+    }
+
+    @ParameterizedTest
+    @MethodSource("createSubstitutionCasesWithOwnExceptions")
+    public void testPerformSubstitutionsWithOwnExceptions(String input, String expected) {
+        NormalizeFieldTransformation transform = createTransformation(
+            "table",
+            "field",
+            null,
+            Lists.newArrayList(
+                new Substitution("Station", "Stn"),
+                new Substitution("#", "AND", true)
+            )
+        );
+        assertEquals(expected, transform.performSubstitutions(input));
+    }
+
+    private static Stream<Arguments> createSubstitutionCasesWithOwnExceptions() {
+        return Stream.of(
+            // Capitalization exceptions from instance (quadrant street names)
+            Arguments.of("Embarcadero Station", "Embarcadero Stn"),
+            Arguments.of("10th#North", "10th AND North")
+        );
+    }
+
+    /**
+     * Proxy to create a transformation
+     * (called by {@link com.conveyal.datatools.manager.jobs.NormalizeFieldTransformJobTest}).
+     */
+    public static NormalizeFieldTransformation createTransformation(
+        String table, String fieldName, List<String> exceptions, List<Substitution> substitutions)
+    {
+        return NormalizeFieldTransformation.create(table, fieldName, exceptions, substitutions);
+    }
+
+    /**
+     * Proxy to create a transformation
+     * (called by {@link com.conveyal.datatools.manager.jobs.NormalizeFieldTransformJobTest}).
+     */
+    public static NormalizeFieldTransformation createTransformation() {
+        return NormalizeFieldTransformation.create("table", "field", null, null);
+    }
+}
diff --git a/src/test/java/com/conveyal/datatools/manager/utils/GtfsUtilsTest.java b/src/test/java/com/conveyal/datatools/manager/utils/GtfsUtilsTest.java
new file mode 100644
index 000000000..80ce1b82b
--- /dev/null
+++ b/src/test/java/com/conveyal/datatools/manager/utils/GtfsUtilsTest.java
@@ -0,0 +1,27 @@
+package com.conveyal.datatools.manager.utils;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Contains tests for GtfsUtils.
+ */
+public class GtfsUtilsTest {
+    @ParameterizedTest
+    @MethodSource("createGetTableNameCases")
+    public void testGetTableNames(String tableName, boolean outcome) {
+        assertEquals(outcome, GtfsUtils.getGtfsTable(tableName) != null);
+    }
+
+    private static Stream<Arguments> createGetTableNameCases() {
+        return Stream.of(
+            Arguments.of("agency", true),
+            Arguments.of("a_nonexistent_table", false)
+        );
+    }
+}