diff --git a/src/common/formatters.ts b/src/common/formatters.ts
index 0011c0459..5d29f77e7 100644
--- a/src/common/formatters.ts
+++ b/src/common/formatters.ts
@@ -71,7 +71,7 @@ export function millisecondsToHMS(valueMS: number): string {
     }
 
     if (valueMS < 1000) {
-        return subSecondString;
+        return `${valueMS}ms`;
     }
 
     const duration = moment.duration(valueMS);
diff --git a/src/common/test/formatters.spec.ts b/src/common/test/formatters.spec.ts
index 718ce5db0..5f209743a 100644
--- a/src/common/test/formatters.spec.ts
+++ b/src/common/test/formatters.spec.ts
@@ -102,8 +102,8 @@ describe('formatDateLocalTimezone', () => {
 const millisecondToHMSTestCases: [number, string][] = [
     [-1, unknownValueString],
     [0, zeroSecondsString],
-    [1, subSecondString],
-    [999, subSecondString],
+    [1, '1ms'],
+    [999, '999ms'],
     [1000, '1s'],
     [60000, '1m'],
     [61000, '1m 1s'],
diff --git a/src/common/utils.ts b/src/common/utils.ts
index cdf07cb5b..c637e21d1 100644
--- a/src/common/utils.ts
+++ b/src/common/utils.ts
@@ -99,3 +99,20 @@ export function sortedObjectKeys(
 ): ReturnType<typeof Object.keys> {
     return Object.keys(object).sort((a, b) => a.localeCompare(b));
 }
+
+/**
+ * Helper function for exhaustive checks of discriminated unions.
+ * https://basarat.gitbooks.io/typescript/docs/types/discriminated-unions.html
+ */
+export function assertNever(
+    value: never,
+    { noThrow }: { noThrow?: boolean } = {}
+): never {
+    if (noThrow) {
+        return value;
+    }
+
+    throw new Error(
+        `Unhandled discriminated union member: ${JSON.stringify(value)}`
+    );
+}
diff --git a/src/components/Launch/LaunchWorkflowForm/BlobInput.tsx b/src/components/Launch/LaunchWorkflowForm/BlobInput.tsx
new file mode 100644
index 000000000..0073c287d
--- /dev/null
+++ b/src/components/Launch/LaunchWorkflowForm/BlobInput.tsx
@@ -0,0 +1,126 @@
+import {
+    FormControl,
+    FormHelperText,
+    InputLabel,
+    MenuItem,
+    Select,
+    TextField,
+    Typography
+} from '@material-ui/core';
+import { makeStyles, Theme } from '@material-ui/core/styles';
+import { BlobDimensionality } from 'models';
+import * as React from 'react';
+import {
+    blobFormatHelperText,
+    blobUriHelperText,
+    defaultBlobValue
+} from './constants';
+import { InputProps } from './types';
+import { getLaunchInputId, isBlobValue } from './utils';
+
+const useStyles = makeStyles((theme: Theme) => ({
+    dimensionalityInput: {
+        flex: '1 1 auto',
+        marginLeft: theme.spacing(2)
+    },
+    formatInput: {
+        flex: '1 1 auto'
+    },
+    inputContainer: {
+        borderLeft: `1px solid ${theme.palette.divider}`,
+        marginTop: theme.spacing(1),
+        paddingLeft: theme.spacing(1)
+    },
+    metadataContainer: {
+        display: 'flex',
+        marginTop: theme.spacing(1),
+        width: '100%'
+    }
+}));
+
+/** A micro form for entering the values related to a Blob Literal */
+export const BlobInput: React.FC<InputProps> = props => {
+    const styles = useStyles();
+    const { error, label, name, onChange, value: propValue } = props;
+    const blobValue = isBlobValue(propValue) ? propValue : defaultBlobValue;
+    const hasError = !!error;
+    const helperText = hasError ? error : props.helperText;
+
+    const handleUriChange = ({
+        target: { value: uri }
+    }: React.ChangeEvent<HTMLInputElement>) => {
+        onChange({
+            ...blobValue,
+            uri
+        });
+    };
+
+    const handleFormatChange = ({
+        target: { value: format }
+    }: React.ChangeEvent<HTMLInputElement>) => {
+        onChange({
+            ...blobValue,
+            format
+        });
+    };
+
+    const handleDimensionalityChange = ({
+        target: { value }
+    }: React.ChangeEvent<{ value: unknown }>) => {
+        onChange({
+            ...blobValue,
+            dimensionality: value as BlobDimensionality
+        });
+    };
+
+    const selectId = getLaunchInputId(`${name}-select`);
+
+    return (
+        <div>
+            <Typography variant="body1" component="label">
+                {label}
+            </Typography>
+            <FormHelperText error={hasError}>{helperText}</FormHelperText>
+            <div className={styles.inputContainer}>
+                <TextField
+                    id={getLaunchInputId(`${name}-uri`)}
+                    helperText={blobUriHelperText}
+                    fullWidth={true}
+                    label="uri"
+                    onChange={handleUriChange}
+                    value={blobValue.uri}
+                    variant="outlined"
+                />
+                <div className={styles.metadataContainer}>
+                    <TextField
+                        className={styles.formatInput}
+                        id={getLaunchInputId(`${name}-format`)}
+                        helperText={blobFormatHelperText}
+                        label="format"
+                        onChange={handleFormatChange}
+                        value={blobValue.format}
+                        variant="outlined"
+                    />
+                    <FormControl className={styles.dimensionalityInput}>
+                        <InputLabel id={`${selectId}-label`}>
+                            Dimensionality
+                        </InputLabel>
+                        <Select
+                            labelId={`${selectId}-label`}
+                            id={selectId}
+                            value={blobValue.dimensionality}
+                            onChange={handleDimensionalityChange}
+                        >
+                            <MenuItem value={BlobDimensionality.SINGLE}>
+                                Single (File)
+                            </MenuItem>
+                            <MenuItem value={BlobDimensionality.MULTIPART}>
+                                Multipart (Directory)
+                            </MenuItem>
+                        </Select>
+                    </FormControl>
+                </div>
+            </div>
+        </div>
+    );
+};
diff --git a/src/components/Launch/LaunchWorkflowForm/LaunchWorkflowForm.tsx b/src/components/Launch/LaunchWorkflowForm/LaunchWorkflowForm.tsx
index 7d48ca917..9157d7983 100644
--- a/src/components/Launch/LaunchWorkflowForm/LaunchWorkflowForm.tsx
+++ b/src/components/Launch/LaunchWorkflowForm/LaunchWorkflowForm.tsx
@@ -16,12 +16,13 @@ import {
     workflowSortFields
 } from 'models';
 import * as React from 'react';
-import { formStrings } from './constants';
+import { formStrings, unsupportedRequiredInputsString } from './constants';
 import { InputValueCacheContext } from './inputValueCache';
 import { LaunchWorkflowFormInputs } from './LaunchWorkflowFormInputs';
 import { SearchableSelector } from './SearchableSelector';
 import { useStyles } from './styles';
 import { LaunchWorkflowFormProps } from './types';
+import { UnsupportedRequiredInputsError } from './UnsupportedRequiredInputsError';
 import { useLaunchWorkflowFormState } from './useLaunchWorkflowFormState';
 import { workflowsToSearchableSelectorOptions } from './utils';
 
@@ -67,6 +68,11 @@ export const LaunchWorkflowForm: React.FC<LaunchWorkflowFormProps> = props => {
         state.onSubmit();
     };
 
+    const preventSubmit =
+        submissionState.loading ||
+        !state.inputLoadingState.hasLoaded ||
+        state.unsupportedRequiredInputs.length > 0;
+
     return (
         <InputValueCacheContext.Provider value={state.inputValueCache}>
             <DialogTitle disableTypography={true} className={styles.header}>
@@ -114,12 +120,18 @@ export const LaunchWorkflowForm: React.FC<LaunchWorkflowFormProps> = props => {
                             {...state.inputLoadingState}
                         >
                             <section title={formStrings.inputs}>
-                                <LaunchWorkflowFormInputs
-                                    key={state.formKey}
-                                    inputs={state.inputs}
-                                    ref={state.formInputsRef}
-                                    showErrors={state.showErrors}
-                                />
+                                {state.unsupportedRequiredInputs.length > 0 ? (
+                                    <UnsupportedRequiredInputsError
+                                        inputs={state.unsupportedRequiredInputs}
+                                    />
+                                ) : (
+                                    <LaunchWorkflowFormInputs
+                                        key={state.formKey}
+                                        inputs={state.inputs}
+                                        ref={state.formInputsRef}
+                                        showErrors={state.showErrors}
+                                    />
+                                )}
                             </section>
                         </WaitForData>
                     ) : null}
@@ -143,10 +155,7 @@ export const LaunchWorkflowForm: React.FC<LaunchWorkflowFormProps> = props => {
                     </Button>
                     <Button
                         color="primary"
-                        disabled={
-                            submissionState.loading ||
-                            !state.inputLoadingState.hasLoaded
-                        }
+                        disabled={preventSubmit}
                         id="launch-workflow-submit"
                         onClick={submit}
                         type="submit"
diff --git a/src/components/Launch/LaunchWorkflowForm/LaunchWorkflowFormInputs.tsx b/src/components/Launch/LaunchWorkflowForm/LaunchWorkflowFormInputs.tsx
index 055f66b1b..ad83ed0ab 100644
--- a/src/components/Launch/LaunchWorkflowForm/LaunchWorkflowFormInputs.tsx
+++ b/src/components/Launch/LaunchWorkflowForm/LaunchWorkflowFormInputs.tsx
@@ -1,4 +1,5 @@
 import * as React from 'react';
+import { BlobInput } from './BlobInput';
 import { CollectionInput } from './CollectionInput';
 import { SimpleInput } from './SimpleInput';
 import { useStyles } from './styles';
@@ -14,6 +15,8 @@ import { useFormInputsState } from './useFormInputsState';
 function getComponentForInput(input: InputProps, showErrors: boolean) {
     const props = { ...input, error: showErrors ? input.error : undefined };
     switch (input.typeDefinition.type) {
+        case InputType.Blob:
+            return <BlobInput {...props} />;
         case InputType.Collection:
             return <CollectionInput {...props} />;
         case InputType.Map:
diff --git a/src/components/Launch/LaunchWorkflowForm/UnsupportedRequiredInputsError.tsx b/src/components/Launch/LaunchWorkflowForm/UnsupportedRequiredInputsError.tsx
new file mode 100644
index 000000000..6d31b61d0
--- /dev/null
+++ b/src/components/Launch/LaunchWorkflowForm/UnsupportedRequiredInputsError.tsx
@@ -0,0 +1,62 @@
+import { makeStyles, Theme } from '@material-ui/core/styles';
+import ErrorOutline from '@material-ui/icons/ErrorOutline';
+import { NonIdealState } from 'components/common';
+import { useCommonStyles } from 'components/common/styles';
+import * as React from 'react';
+import {
+    cannotLaunchWorkflowString,
+    requiredInputSuffix,
+    unsupportedRequiredInputsString
+} from './constants';
+import { ParsedInput } from './types';
+
+const useStyles = makeStyles((theme: Theme) => ({
+    contentContainer: {
+        whiteSpace: 'pre-line',
+        textAlign: 'left'
+    },
+    errorContainer: {
+        marginBottom: theme.spacing(2)
+    }
+}));
+
+function formatLabel(label: string) {
+    return label.endsWith(requiredInputSuffix)
+        ? label.substring(0, label.length - 1)
+        : label;
+}
+
+export interface UnsupportedRequiredInputsErrorProps {
+    inputs: ParsedInput[];
+}
+/** An informational error to be shown if a Workflow cannot be launch due to
+ * required inputs for which we will not be able to provide a value.
+ */
+export const UnsupportedRequiredInputsError: React.FC<UnsupportedRequiredInputsErrorProps> = ({
+    inputs
+}) => {
+    const styles = useStyles();
+    const commonStyles = useCommonStyles();
+    return (
+        <NonIdealState
+            className={styles.errorContainer}
+            icon={ErrorOutline}
+            size="medium"
+            title={cannotLaunchWorkflowString}
+        >
+            <div className={styles.contentContainer}>
+                <p>{unsupportedRequiredInputsString}</p>
+                <ul className={commonStyles.listUnstyled}>
+                    {inputs.map(input => (
+                        <li
+                            key={input.name}
+                            className={commonStyles.textMonospace}
+                        >
+                            {formatLabel(input.label)}
+                        </li>
+                    ))}
+                </ul>
+            </div>
+        </NonIdealState>
+    );
+};
diff --git a/src/components/Launch/LaunchWorkflowForm/__mocks__/mockInputs.ts b/src/components/Launch/LaunchWorkflowForm/__mocks__/mockInputs.ts
index 8f1a67116..614055025 100644
--- a/src/components/Launch/LaunchWorkflowForm/__mocks__/mockInputs.ts
+++ b/src/components/Launch/LaunchWorkflowForm/__mocks__/mockInputs.ts
@@ -2,7 +2,12 @@ import { dateToTimestamp, millisecondsToDuration } from 'common/utils';
 import { Core } from 'flyteidl';
 import { mapValues } from 'lodash';
 import * as Long from 'long';
-import { SimpleType, TypedInterface, Variable } from 'models/Common';
+import {
+    BlobDimensionality,
+    SimpleType,
+    TypedInterface,
+    Variable
+} from 'models/Common';
 import { literalNone } from '../inputHelpers/constants';
 import { primitiveLiteral } from './utils';
 
@@ -23,6 +28,7 @@ export type SimpleVariableKey =
     | 'simpleInteger'
     | 'simpleFloat'
     | 'simpleBoolean'
+    | 'simpleBlob'
     | 'simpleDuration'
     | 'simpleDatetime'
     | 'simpleBinary'
@@ -39,11 +45,14 @@ export const mockSimpleVariables: Record<SimpleVariableKey, Variable> = {
     simpleDatetime: simpleType(SimpleType.DATETIME, 'a simple datetime value'),
     simpleBinary: simpleType(SimpleType.BINARY, 'a simple binary value'),
     simpleError: simpleType(SimpleType.ERROR, 'a simple error value'),
-    simpleStruct: simpleType(SimpleType.STRUCT, 'a simple struct value')
+    simpleStruct: simpleType(SimpleType.STRUCT, 'a simple struct value'),
+    simpleBlob: {
+        description: 'a simple single-dimensional blob',
+        type: { blob: { dimensionality: BlobDimensionality.SINGLE } }
+    }
     // schema: {},
     // collection: {},
-    // mapValue: {},
-    // blob: {}
+    // mapValue: {}
 };
 
 export const simpleVariableDefaults: Record<
@@ -63,7 +72,20 @@ export const simpleVariableDefaults: Record<
     simpleError: literalNone(),
     simpleFloat: primitiveLiteral({ floatValue: 1.5 }),
     simpleInteger: primitiveLiteral({ integer: Long.fromNumber(12345) }),
-    simpleStruct: literalNone()
+    simpleStruct: literalNone(),
+    simpleBlob: {
+        scalar: {
+            blob: {
+                uri: 's3://someBlobUri/goesHere',
+                metadata: {
+                    type: {
+                        format: 'csv',
+                        dimensionality: BlobDimensionality.SINGLE
+                    }
+                }
+            }
+        }
+    }
 };
 
 export const mockCollectionVariables: Record<string, Variable> = mapValues(
diff --git a/src/components/Launch/LaunchWorkflowForm/__mocks__/utils.ts b/src/components/Launch/LaunchWorkflowForm/__mocks__/utils.ts
index 6584ea8a0..4b41bf796 100644
--- a/src/components/Launch/LaunchWorkflowForm/__mocks__/utils.ts
+++ b/src/components/Launch/LaunchWorkflowForm/__mocks__/utils.ts
@@ -1,5 +1,22 @@
 import { Core } from 'flyteidl';
+import { BlobDimensionality } from 'models';
 
 export function primitiveLiteral(primitive: Core.IPrimitive): Core.ILiteral {
     return { scalar: { primitive } };
 }
+
+export function blobLiteral({
+    uri,
+    format,
+    dimensionality
+}: {
+    uri?: string;
+    format?: string;
+    dimensionality?: BlobDimensionality;
+}): Core.ILiteral {
+    return {
+        scalar: {
+            blob: { uri, metadata: { type: { format, dimensionality } } }
+        }
+    };
+}
diff --git a/src/components/Launch/LaunchWorkflowForm/__stories__/LaunchWorkflowForm.stories.tsx b/src/components/Launch/LaunchWorkflowForm/__stories__/LaunchWorkflowForm.stories.tsx
index c9e7d3138..d7497d34b 100644
--- a/src/components/Launch/LaunchWorkflowForm/__stories__/LaunchWorkflowForm.stories.tsx
+++ b/src/components/Launch/LaunchWorkflowForm/__stories__/LaunchWorkflowForm.stories.tsx
@@ -31,10 +31,12 @@ import {
     SimpleVariableKey
 } from '../__mocks__/mockInputs';
 import { LaunchWorkflowForm } from '../LaunchWorkflowForm';
+import { binaryInputName, errorInputName } from '../test/constants';
 import { useExecutionLaunchConfiguration } from '../useExecutionLaunchConfiguration';
 import { getWorkflowInputs } from '../utils';
 
 const booleanInputName = 'simpleBoolean';
+const blobInputName = 'simpleBlob';
 const stringInputName = 'simpleString';
 const integerInputName = 'simpleInteger';
 const submitAction = action('createWorkflowExecution');
@@ -167,6 +169,7 @@ stories.add('Required Inputs', () => {
     parameters[stringInputName].required = true;
     parameters[integerInputName].required = true;
     parameters[booleanInputName].required = true;
+    parameters[blobInputName].required = true;
     return renderForm({ mocks });
 });
 stories.add('Default Values', () => {
@@ -200,3 +203,10 @@ stories.add('Launched from Execution', () => {
     } as Execution;
     return renderForm({ mocks, execution });
 });
+stories.add('Unsupported Required Values', () => {
+    const mocks = generateMocks(mockSimpleVariables);
+    const parameters = mocks.mockLaunchPlan.closure!.expectedInputs.parameters;
+    parameters[binaryInputName].required = true;
+    parameters[errorInputName].required = true;
+    return renderForm({ mocks });
+});
diff --git a/src/components/Launch/LaunchWorkflowForm/constants.ts b/src/components/Launch/LaunchWorkflowForm/constants.ts
index c7d6c1dd4..c873f7ab2 100644
--- a/src/components/Launch/LaunchWorkflowForm/constants.ts
+++ b/src/components/Launch/LaunchWorkflowForm/constants.ts
@@ -1,5 +1,5 @@
-import { SimpleType } from 'models';
-import { InputType } from './types';
+import { BlobDimensionality, SimpleType } from 'models';
+import { BlobValue, InputType } from './types';
 
 export const launchPlansTableRowHeight = 40;
 export const launchPlansTableColumnWidths = {
@@ -25,7 +25,7 @@ export const formStrings = {
 /** Maps any valid InputType enum to a display string */
 export const typeLabels: { [k in InputType]: string } = {
     [InputType.Binary]: 'binary',
-    [InputType.Blob]: 'blob',
+    [InputType.Blob]: 'file/blob',
     [InputType.Boolean]: 'boolean',
     [InputType.Collection]: '',
     [InputType.Datetime]: 'datetime - UTC',
@@ -54,3 +54,14 @@ export const simpleTypeToInputType: { [k in SimpleType]: InputType } = {
     [SimpleType.STRING]: InputType.String,
     [SimpleType.STRUCT]: InputType.Struct
 };
+
+export const defaultBlobValue: BlobValue = {
+    uri: '',
+    dimensionality: BlobDimensionality.SINGLE
+};
+
+export const requiredInputSuffix = '*';
+export const cannotLaunchWorkflowString = 'Workflow cannot be launched';
+export const unsupportedRequiredInputsString = `This Workflow version contains one or more required inputs which are not supported by Flyte Console and do not have default values specified in the Workflow definition or the selected Launch Plan.\n\nYou can launch this Workflow version with the Flyte CLI or by selecting a Launch Plan which provides values for the unsupported inputs.\n\nThe required inputs are :`;
+export const blobUriHelperText = '(required) location of the data';
+export const blobFormatHelperText = '(optional) csv, parquet, etc...';
diff --git a/src/components/Launch/LaunchWorkflowForm/getInputs.ts b/src/components/Launch/LaunchWorkflowForm/getInputs.ts
index f760264e0..63dd7c754 100644
--- a/src/components/Launch/LaunchWorkflowForm/getInputs.ts
+++ b/src/components/Launch/LaunchWorkflowForm/getInputs.ts
@@ -1,5 +1,6 @@
 import { sortedObjectEntries } from 'common/utils';
 import { LaunchPlan, Workflow } from 'models';
+import { requiredInputSuffix } from './constants';
 import { LiteralValueMap, ParsedInput } from './types';
 import {
     createInputCacheKey,
@@ -36,7 +37,9 @@ export function getInputs(
             parameter.var.type
         );
         const typeLabel = formatLabelWithType(name, typeDefinition);
-        const label = required ? `${typeLabel}*` : typeLabel;
+        const label = required
+            ? `${typeLabel}${requiredInputSuffix}`
+            : typeLabel;
         const inputKey = createInputCacheKey(name, typeDefinition);
         const defaultVaue =
             parameter.default != null ? parameter.default : undefined;
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/blob.ts b/src/components/Launch/LaunchWorkflowForm/inputHelpers/blob.ts
new file mode 100644
index 000000000..114c68e7a
--- /dev/null
+++ b/src/components/Launch/LaunchWorkflowForm/inputHelpers/blob.ts
@@ -0,0 +1,92 @@
+import { Core } from 'flyteidl';
+import { isObject } from 'lodash';
+import { BlobDimensionality } from 'models';
+import { BlobValue, InputValue } from '../types';
+import { literalNone } from './constants';
+import { ConverterInput, InputHelper, InputValidatorParams } from './types';
+import { isKeyOfBlobDimensionality } from './utils';
+
+function fromLiteral(literal: Core.ILiteral): InputValue {
+    if (!literal.scalar || !literal.scalar.blob) {
+        throw new Error('Literal blob missing scalar.blob property');
+    }
+    const { blob } = literal.scalar;
+    const uri = blob.uri ?? '';
+    // throw away empty format values
+    const format = blob.metadata?.type?.format || undefined;
+    const dimensionality =
+        blob.metadata?.type?.dimensionality ?? BlobDimensionality.SINGLE;
+
+    return {
+        dimensionality,
+        format,
+        uri
+    };
+}
+
+// Allows for string values ('single'/'multipart') when specifying blobs manually in collections
+function getDimensionality(value: string | number) {
+    if (typeof value === 'number') {
+        return value;
+    }
+    const normalizedValue = value.toUpperCase();
+    if (isKeyOfBlobDimensionality(normalizedValue)) {
+        return BlobDimensionality[normalizedValue];
+    }
+    return -1;
+}
+
+function toLiteral({ value }: ConverterInput): Core.ILiteral {
+    if (!isObject(value)) {
+        return literalNone();
+    }
+    const {
+        dimensionality: rawDimensionality,
+        format: rawFormat,
+        uri
+    } = value as BlobValue;
+    if (!uri) {
+        return literalNone();
+    }
+
+    const dimensionality = getDimensionality(rawDimensionality);
+
+    // Send undefined for empty string values of format
+    const format = rawFormat ? rawFormat : undefined;
+    return {
+        scalar: {
+            blob: { uri, metadata: { type: { dimensionality, format } } }
+        }
+    };
+}
+
+function validate({ value, required }: InputValidatorParams) {
+    if (typeof value !== 'object') {
+        throw new Error('Value must be an object');
+    }
+
+    const blobValue = value as BlobValue;
+    if (required && (typeof blobValue.uri == null || !blobValue.uri.length)) {
+        throw new Error('uri is required');
+    }
+    if (blobValue != null && typeof blobValue.uri !== 'string') {
+        throw new Error('uri must be a string');
+    }
+    if (blobValue.dimensionality == null) {
+        throw new Error('dimensionality is required');
+    }
+    if (!(getDimensionality(blobValue.dimensionality) in BlobDimensionality)) {
+        throw new Error(
+            `unknown dimensionality value: ${blobValue.dimensionality}`
+        );
+    }
+    if (blobValue.format != null && typeof blobValue.format !== 'string') {
+        throw new Error('format must be a string');
+    }
+}
+
+export const blobHelper: InputHelper = {
+    fromLiteral,
+    toLiteral,
+    validate
+};
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/boolean.ts b/src/components/Launch/LaunchWorkflowForm/inputHelpers/boolean.ts
index 5de989e65..8a13991d7 100644
--- a/src/components/Launch/LaunchWorkflowForm/inputHelpers/boolean.ts
+++ b/src/components/Launch/LaunchWorkflowForm/inputHelpers/boolean.ts
@@ -1,7 +1,7 @@
 import { Core } from 'flyteidl';
 import { InputValue } from '../types';
 import { primitiveLiteralPaths } from './constants';
-import { ConverterInput, InputHelper } from './types';
+import { ConverterInput, InputHelper, InputValidatorParams } from './types';
 import { extractLiteralWithCheck } from './utils';
 
 /** Checks that a value is an acceptable boolean value. These can be
@@ -47,7 +47,7 @@ function fromLiteral(literal: Core.ILiteral): InputValue {
     );
 }
 
-function validate({ value }: ConverterInput) {
+function validate({ value }: InputValidatorParams) {
     if (!isValidBoolean(value)) {
         throw new Error('Value is not a valid boolean');
     }
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/collection.ts b/src/components/Launch/LaunchWorkflowForm/inputHelpers/collection.ts
index 7bff336b8..5bc1d7db8 100644
--- a/src/components/Launch/LaunchWorkflowForm/inputHelpers/collection.ts
+++ b/src/components/Launch/LaunchWorkflowForm/inputHelpers/collection.ts
@@ -1,9 +1,9 @@
 import { Core } from 'flyteidl';
-import { InputType, InputTypeDefinition, InputValue } from '../types';
+import { InputTypeDefinition, InputValue } from '../types';
 import { literalNone } from './constants';
 import { getHelperForInput } from './getHelperForInput';
 import { parseJSON } from './parseJson';
-import { ConverterInput, InputHelper } from './types';
+import { ConverterInput, InputHelper, InputValidatorParams } from './types';
 import { collectionChildToString } from './utils';
 
 const missingSubTypeError = 'Unexpected missing subtype for collection';
@@ -81,7 +81,7 @@ function toLiteral({
     };
 }
 
-function validate({ value }: ConverterInput) {
+function validate({ value }: InputValidatorParams) {
     if (typeof value !== 'string') {
         throw new Error('Value must be a string');
     }
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/datetime.ts b/src/components/Launch/LaunchWorkflowForm/inputHelpers/datetime.ts
index f1c5a1998..27df2d4ae 100644
--- a/src/components/Launch/LaunchWorkflowForm/inputHelpers/datetime.ts
+++ b/src/components/Launch/LaunchWorkflowForm/inputHelpers/datetime.ts
@@ -3,7 +3,7 @@ import { Core, Protobuf } from 'flyteidl';
 import { utc as moment } from 'moment';
 import { InputValue } from '../types';
 import { allowedDateFormats, primitiveLiteralPaths } from './constants';
-import { ConverterInput, InputHelper } from './types';
+import { ConverterInput, InputHelper, InputValidatorParams } from './types';
 import { extractLiteralWithCheck } from './utils';
 
 function parseDate(value: InputValue) {
@@ -27,7 +27,7 @@ function toLiteral({ value }: ConverterInput): Core.ILiteral {
     };
 }
 
-function validate({ value }: ConverterInput) {
+function validate({ value }: InputValidatorParams) {
     const parsed = parseDate(value);
     if (Number.isNaN(parsed.getTime())) {
         throw new Error('Value is not a valid Date');
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/duration.ts b/src/components/Launch/LaunchWorkflowForm/inputHelpers/duration.ts
index 8af578678..223cec63e 100644
--- a/src/components/Launch/LaunchWorkflowForm/inputHelpers/duration.ts
+++ b/src/components/Launch/LaunchWorkflowForm/inputHelpers/duration.ts
@@ -3,7 +3,7 @@ import { Core, Protobuf } from 'flyteidl';
 import { InputValue } from '../types';
 import { primitiveLiteralPaths } from './constants';
 import { isValidFloat } from './float';
-import { ConverterInput, InputHelper } from './types';
+import { ConverterInput, InputHelper, InputValidatorParams } from './types';
 import { extractLiteralWithCheck } from './utils';
 
 function fromLiteral(literal: Core.ILiteral): InputValue {
@@ -23,7 +23,7 @@ function toLiteral({ value }: ConverterInput): Core.ILiteral {
     };
 }
 
-function validate({ value }: ConverterInput) {
+function validate({ value }: InputValidatorParams) {
     if (!isValidFloat(value)) {
         throw new Error('Value is not a valid duration');
     }
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/float.ts b/src/components/Launch/LaunchWorkflowForm/inputHelpers/float.ts
index 7a3676767..25f1f87f8 100644
--- a/src/components/Launch/LaunchWorkflowForm/inputHelpers/float.ts
+++ b/src/components/Launch/LaunchWorkflowForm/inputHelpers/float.ts
@@ -1,7 +1,7 @@
 import { Core } from 'flyteidl';
 import { InputValue } from '../types';
 import { primitiveLiteralPaths } from './constants';
-import { ConverterInput, InputHelper } from './types';
+import { ConverterInput, InputHelper, InputValidatorParams } from './types';
 import { extractLiteralWithCheck } from './utils';
 
 function fromLiteral(literal: Core.ILiteral): InputValue {
@@ -29,7 +29,7 @@ export function isValidFloat(value: InputValue): boolean {
     return false;
 }
 
-function validate({ value }: ConverterInput) {
+function validate({ value }: InputValidatorParams) {
     if (!isValidFloat(value)) {
         throw new Error('Value is not a valid floating point number');
     }
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/getHelperForInput.ts b/src/components/Launch/LaunchWorkflowForm/inputHelpers/getHelperForInput.ts
index eff77c21d..ef6c69ec8 100644
--- a/src/components/Launch/LaunchWorkflowForm/inputHelpers/getHelperForInput.ts
+++ b/src/components/Launch/LaunchWorkflowForm/inputHelpers/getHelperForInput.ts
@@ -1,4 +1,5 @@
 import { InputType } from '../types';
+import { blobHelper } from './blob';
 import { booleanHelper } from './boolean';
 import { collectionHelper } from './collection';
 import { datetimeHelper } from './datetime';
@@ -14,7 +15,7 @@ const unsupportedHelper = noneHelper;
 /** Maps an `InputType` to a function which will convert its value into a `Literal` */
 const inputHelpers: Record<InputType, InputHelper> = {
     [InputType.Binary]: noneHelper,
-    [InputType.Blob]: unsupportedHelper,
+    [InputType.Blob]: blobHelper,
     [InputType.Boolean]: booleanHelper,
     [InputType.Collection]: collectionHelper,
     [InputType.Datetime]: datetimeHelper,
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/inputHelpers.ts b/src/components/Launch/LaunchWorkflowForm/inputHelpers/inputHelpers.ts
index ce063bacf..1c3f5d2d5 100644
--- a/src/components/Launch/LaunchWorkflowForm/inputHelpers/inputHelpers.ts
+++ b/src/components/Launch/LaunchWorkflowForm/inputHelpers/inputHelpers.ts
@@ -3,6 +3,7 @@ import { Core } from 'flyteidl';
 import { InputProps, InputTypeDefinition, InputValue } from '../types';
 import { literalNone } from './constants';
 import { getHelperForInput } from './getHelperForInput';
+import { InputValidatorParams, ValidationParams } from './types';
 
 type ToLiteralParams = Pick<
     InputProps,
@@ -56,20 +57,12 @@ export function literalToInputValue(
     }
 }
 
-type ValidationParams = Pick<
-    InputProps,
-    'initialValue' | 'name' | 'required' | 'typeDefinition' | 'value'
->;
 /** Validates a given InputValue based on rules for the provided type. Returns
  * void if no errors, throws an error otherwise.
  */
-export function validateInput({
-    initialValue,
-    name,
-    required,
-    typeDefinition,
-    value
-}: ValidationParams) {
+export function validateInput(params: ValidationParams) {
+    const { initialValue, name, required, typeDefinition, value } = params;
+    const { validate } = getHelperForInput(typeDefinition.type);
     if (value == null) {
         if (required && initialValue == null) {
             throw new ValueError(name, 'Value is required');
@@ -77,9 +70,8 @@ export function validateInput({
         return;
     }
 
-    const { validate } = getHelperForInput(typeDefinition.type);
     try {
-        validate({ value, typeDefinition });
+        validate(params as InputValidatorParams);
     } catch (e) {
         const error = e as Error;
         throw new ValueError(name, error.message);
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/integer.ts b/src/components/Launch/LaunchWorkflowForm/inputHelpers/integer.ts
index 2a962c167..96387c755 100644
--- a/src/components/Launch/LaunchWorkflowForm/inputHelpers/integer.ts
+++ b/src/components/Launch/LaunchWorkflowForm/inputHelpers/integer.ts
@@ -2,7 +2,7 @@ import { Core } from 'flyteidl';
 import * as Long from 'long';
 import { InputValue } from '../types';
 import { primitiveLiteralPaths } from './constants';
-import { ConverterInput, InputHelper } from './types';
+import { ConverterInput, InputHelper, InputValidatorParams } from './types';
 import { extractLiteralWithCheck } from './utils';
 
 const integerRegexPattern = /^-?[0-9]+$/;
@@ -35,7 +35,7 @@ export function isValidInteger(value: InputValue): boolean {
     return false;
 }
 
-function validate({ value }: ConverterInput) {
+function validate({ value }: InputValidatorParams) {
     if (!isValidInteger(value)) {
         throw new Error('Value is not a valid integer');
     }
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/string.ts b/src/components/Launch/LaunchWorkflowForm/inputHelpers/string.ts
index 46364e8bf..ec5c55b79 100644
--- a/src/components/Launch/LaunchWorkflowForm/inputHelpers/string.ts
+++ b/src/components/Launch/LaunchWorkflowForm/inputHelpers/string.ts
@@ -1,7 +1,7 @@
 import { Core } from 'flyteidl';
 import { InputValue } from '../types';
 import { primitiveLiteralPaths } from './constants';
-import { ConverterInput, InputHelper } from './types';
+import { ConverterInput, InputHelper, InputValidatorParams } from './types';
 import { extractLiteralWithCheck } from './utils';
 
 function fromLiteral(literal: Core.ILiteral): InputValue {
@@ -16,7 +16,7 @@ function toLiteral({ value }: ConverterInput): Core.ILiteral {
     return { scalar: { primitive: { stringValue } } };
 }
 
-function validate({ value }: ConverterInput) {
+function validate({ value }: InputValidatorParams) {
     if (typeof value !== 'string') {
         throw new Error('Value is not a string');
     }
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/test/inputHelpers.test.ts b/src/components/Launch/LaunchWorkflowForm/inputHelpers/test/inputHelpers.test.ts
index 95ec7e687..b62c6211a 100644
--- a/src/components/Launch/LaunchWorkflowForm/inputHelpers/test/inputHelpers.test.ts
+++ b/src/components/Launch/LaunchWorkflowForm/inputHelpers/test/inputHelpers.test.ts
@@ -1,4 +1,6 @@
 import { Core } from 'flyteidl';
+import * as Long from 'long';
+import { BlobDimensionality } from 'models';
 import { primitiveLiteral } from '../../__mocks__/utils';
 import { InputProps, InputType } from '../../types';
 import { literalNone } from '../constants';
@@ -12,6 +14,8 @@ import { collectionChildToString } from '../utils';
 import {
     literalTestCases,
     literalToInputTestCases,
+    supportedPrimitives,
+    unsupportedTypes,
     validityTestCases
 } from './testCases';
 
@@ -51,39 +55,28 @@ describe('literalToInputValue', () => {
     describe('Primitives', () => {
         literalToInputTestCases.map(([type, input, output]) =>
             it(`should correctly convert ${type}: ${JSON.stringify(
-                input.scalar!.primitive
-            )}`, () => {
-                const result = literalToInputValue({ type }, input);
-                expect(result).toEqual(output);
-            })
+                input
+            )}`, () =>
+                expect(literalToInputValue({ type }, input)).toEqual(output))
         );
 
-        [
-            InputType.Collection,
-            InputType.Datetime,
-            InputType.Duration,
-            InputType.Float,
-            InputType.Integer,
-            InputType.String
-        ].map(type =>
-            it(`should convert None value for ${type} to undefined`, () => {
+        supportedPrimitives.map(type =>
+            it(`should convert None value for ${type} to undefined`, () =>
                 expect(
                     literalToInputValue({ type }, literalNone())
-                ).toBeUndefined();
-            })
+                ).toBeUndefined())
         );
 
-        it('should correctly convert noneType to undefined', () => {
+        it('should correctly convert noneType to undefined', () =>
             expect(
                 literalToInputValue({ type: InputType.None }, literalNone())
-            ).toEqual(undefined);
-        });
+            ).toEqual(undefined));
     });
 
     describe('Collections', () => {
-        literalToInputTestCases.map(([type, input, output]) =>
+        literalToInputTestCases.map(([type, input, output]) => {
             it(`should correctly convert collection of ${type}: ${JSON.stringify(
-                input.scalar!.primitive
+                input
             )}`, () => {
                 const collection: Core.ILiteral = {
                     collection: {
@@ -98,8 +91,8 @@ describe('literalToInputValue', () => {
                     collection
                 );
                 expect(result).toEqual(expectedString);
-            })
-        );
+            });
+        });
 
         it('should return empty for noneType literals', () => {
             const collection: Core.ILiteral = {
@@ -134,13 +127,15 @@ describe('literalToInputValue', () => {
 });
 
 describe('inputToLiteral', () => {
-    describe('Primitives', () => {
-        literalTestCases.map(([type, input, output]) =>
-            it(`should correctly convert ${type}: ${input} (${typeof input})`, () => {
-                const result = inputToLiteral(makeSimpleInput(type, input));
-                expect(result.scalar!.primitive).toEqual(output);
-            })
-        );
+    describe('Scalars', () => {
+        literalTestCases.map(([type, input, output]) => {
+            it(`should correctly convert ${type}: ${JSON.stringify(
+                input
+            )} (${typeof input})`, () =>
+                expect(inputToLiteral(makeSimpleInput(type, input))).toEqual(
+                    output
+                ));
+        });
     });
 
     describe('Collections', () => {
@@ -148,44 +143,40 @@ describe('inputToLiteral', () => {
             let value: any;
             if (['boolean', 'number'].includes(typeof input)) {
                 value = input;
+            } else if (input == null) {
+                value = 'null';
+            } else if (typeof input === 'string' || Long.isLong(input)) {
+                value = `"${input}"`;
             } else if (input instanceof Date) {
                 value = `"${input.toISOString()}"`;
             } else {
-                value = `"${input}"`;
+                value = JSON.stringify(input);
             }
 
-            it(`should correctly convert collection of type ${type}: [${value}] (${typeof input})`, () => {
+            it(`should correctly convert collection of type ${type}: [${JSON.stringify(
+                value
+            )}] (${typeof input})`, () => {
                 const result = inputToLiteral(
                     makeCollectionInput(type, `[${value}]`)
                 );
-                expect(
-                    result.collection!.literals![0].scalar!.primitive
-                ).toEqual(output);
+                expect(result.collection!.literals![0]).toEqual(output);
             });
 
-            it(`should correctly convert nested collection of type ${type}: [[${value}]] (${typeof input})`, () => {
+            it(`should correctly convert nested collection of type ${type}: [[${JSON.stringify(
+                value
+            )}]] (${typeof input})`, () => {
                 const result = inputToLiteral(
                     makeNestedCollectionInput(type, `[[${value}]]`)
                 );
                 expect(
                     result.collection!.literals![0].collection!.literals![0]
-                        .scalar!.primitive
                 ).toEqual(output);
             });
         });
     });
 
     describe('Unsupported Types', () => {
-        [
-            InputType.Binary,
-            InputType.Blob,
-            InputType.Error,
-            InputType.Map,
-            InputType.None,
-            InputType.Schema,
-            InputType.Struct,
-            InputType.Unknown
-        ].map(type =>
+        unsupportedTypes.map(type =>
             it(`should return empty value for type: ${type}`, () => {
                 expect(
                     inputToLiteral(makeSimpleInput(type, '')).scalar
@@ -212,13 +203,17 @@ function generateValidityTests(
     { valid, invalid }: { valid: any[]; invalid: any[] }
 ) {
     valid.map(value =>
-        it(`should treat ${value} (${typeof value}) as valid`, () => {
+        it(`should treat ${JSON.stringify(
+            value
+        )} (${typeof value}) as valid`, () => {
             const input = makeSimpleInput(type, value);
             expect(() => validateInput(input)).not.toThrowError();
         })
     );
     invalid.map(value =>
-        it(`should treat ${value} (${typeof value}) as invalid`, () => {
+        it(`should treat ${JSON.stringify(
+            value
+        )} (${typeof value}) as invalid`, () => {
             const input = makeSimpleInput(type, value);
             expect(() => validateInput(input)).toThrowError();
         })
@@ -229,6 +224,10 @@ describe('validateInput', () => {
         generateValidityTests(InputType.Boolean, validityTestCases.boolean);
     });
 
+    describe('blob', () => {
+        generateValidityTests(InputType.Blob, validityTestCases.blob);
+    });
+
     describe('datetime', () => {
         generateValidityTests(InputType.Datetime, validityTestCases.datetime);
     });
@@ -249,7 +248,7 @@ describe('validateInput', () => {
         generateValidityTests(InputType.String, validityTestCases.string);
     });
 
-    it('should throw errors for missing required values', () => {
+    it('should throw errors for missing required simple values', () => {
         const [type, input] = literalTestCases[0];
         const simpleInput = makeSimpleInput(type, input);
         simpleInput.required = true;
@@ -257,6 +256,16 @@ describe('validateInput', () => {
         expect(() => validateInput(simpleInput)).toThrowError();
     });
 
+    it('should throw errors for missing required Blob values', () => {
+        // URI is the only required, user-provided value with no default
+        const simpleInput = makeSimpleInput(InputType.Blob, {
+            format: 'csv',
+            dimensionality: BlobDimensionality.SINGLE
+        });
+        simpleInput.required = true;
+        expect(() => validateInput(simpleInput)).toThrowError();
+    });
+
     it('should not throw an error for a required input with an initial value and no value', () => {
         const simpleInput = makeSimpleInput(
             InputType.String,
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/test/testCases.ts b/src/components/Launch/LaunchWorkflowForm/inputHelpers/test/testCases.ts
index 8524c21c3..99c69a215 100644
--- a/src/components/Launch/LaunchWorkflowForm/inputHelpers/test/testCases.ts
+++ b/src/components/Launch/LaunchWorkflowForm/inputHelpers/test/testCases.ts
@@ -1,19 +1,78 @@
 import { dateToTimestamp, millisecondsToDuration } from 'common/utils';
 import { Core } from 'flyteidl';
 import * as Long from 'long';
-import { primitiveLiteral } from '../../__mocks__/utils';
+import { BlobDimensionality } from 'models';
+import { blobLiteral, primitiveLiteral } from '../../__mocks__/utils';
 import { InputType, InputValue } from '../../types';
+import { literalNone } from '../constants';
 
-// Defines type of value, input, and expected value of innermost `IScalar`
-type PrimitiveTestParams = [InputType, any, Core.IPrimitive];
+// Defines type of value, input, and expected value of a `Core.ILiteral`
+type LiteralTestParams = [InputType, any, Core.ILiteral];
 
 const validDateString = '2019-01-10T00:00:00.000Z'; // Dec 1, 2019
 
+export const supportedPrimitives = [
+    InputType.Boolean,
+    InputType.Blob,
+    InputType.Datetime,
+    InputType.Duration,
+    InputType.Float,
+    InputType.Integer
+];
+
+export const unsupportedTypes = [
+    InputType.Binary,
+    InputType.Error,
+    InputType.Map,
+    InputType.None,
+    InputType.Schema,
+    InputType.Struct
+];
+
 export const validityTestCases = {
     boolean: {
         invalid: ['randomString', {}, new Date()],
         valid: [true, 'true', 't', '1', 1, false, 'false', 'f', '0', 0]
     },
+    blob: {
+        invalid: [
+            {
+                uri: 5,
+                format: 'csv',
+                dimensionality: BlobDimensionality.SINGLE
+            },
+            {
+                uri: 'path',
+                format: 5,
+                dimensionality: BlobDimensionality.SINGLE
+            },
+            { uri: 'path', dimensionality: 'notAnEnumValue' },
+            { uri: 'path', dimensionality: 1000 },
+            { uri: 'path' }
+        ],
+        valid: [
+            {
+                uri: 'path',
+                format: 'csv',
+                dimensionality: BlobDimensionality.SINGLE
+            },
+            {
+                uri: 'path',
+                format: 'csv',
+                dimensionality: BlobDimensionality.MULTIPART
+            },
+            { uri: 'path', format: 'csv', dimensionality: 'single' },
+            { uri: 'path', format: 'csv', dimensionality: 'SINGLE' },
+            { uri: 'path', format: 'csv', dimensionality: 'multipart' },
+            { uri: 'path', format: 'csv', dimensionality: 'MULTIPART' },
+            {
+                uri: 'path',
+                format: '',
+                dimensionality: BlobDimensionality.SINGLE
+            },
+            { uri: 'path', dimensionality: BlobDimensionality.SINGLE }
+        ]
+    },
     datetime: {
         invalid: ['abc', true],
         valid: [new Date(validDateString), validDateString]
@@ -51,52 +110,206 @@ export const validityTestCases = {
     string: { invalid: [123, true, new Date(), {}], valid: ['', 'abcdefg'] }
 };
 
-export const literalTestCases: PrimitiveTestParams[] = [
-    [InputType.Boolean, true, { boolean: true }],
-    [InputType.Boolean, 'true', { boolean: true }],
-    [InputType.Boolean, 't', { boolean: true }],
-    [InputType.Boolean, '1', { boolean: true }],
-    [InputType.Boolean, 1, { boolean: true }],
-    [InputType.Boolean, false, { boolean: false }],
-    [InputType.Boolean, 'false', { boolean: false }],
-    [InputType.Boolean, 'f', { boolean: false }],
-    [InputType.Boolean, '0', { boolean: false }],
-    [InputType.Boolean, 0, { boolean: false }],
+export const literalTestCases: LiteralTestParams[] = [
+    [InputType.Boolean, true, primitiveLiteral({ boolean: true })],
+    [InputType.Boolean, 'true', primitiveLiteral({ boolean: true })],
+    [InputType.Boolean, 't', primitiveLiteral({ boolean: true })],
+    [InputType.Boolean, '1', primitiveLiteral({ boolean: true })],
+    [InputType.Boolean, 1, primitiveLiteral({ boolean: true })],
+    [InputType.Boolean, false, primitiveLiteral({ boolean: false })],
+    [InputType.Boolean, 'false', primitiveLiteral({ boolean: false })],
+    [InputType.Boolean, 'f', primitiveLiteral({ boolean: false })],
+    [InputType.Boolean, '0', primitiveLiteral({ boolean: false })],
+    [InputType.Boolean, 0, primitiveLiteral({ boolean: false })],
     [
         InputType.Datetime,
         new Date(validDateString),
-        { datetime: dateToTimestamp(new Date(validDateString)) }
+        primitiveLiteral({
+            datetime: dateToTimestamp(new Date(validDateString))
+        })
     ],
     [
         InputType.Datetime,
         validDateString,
-        { datetime: dateToTimestamp(new Date(validDateString)) }
-    ],
-    [InputType.Duration, 0, { duration: millisecondsToDuration(0) }],
-    [InputType.Duration, 10000, { duration: millisecondsToDuration(10000) }],
-    [InputType.Float, 0, { floatValue: 0 }],
-    [InputType.Float, '0', { floatValue: 0 }],
-    [InputType.Float, -1.5, { floatValue: -1.5 }],
-    [InputType.Float, '-1.5', { floatValue: -1.5 }],
-    [InputType.Float, 1.5, { floatValue: 1.5 }],
-    [InputType.Float, '1.5', { floatValue: 1.5 }],
-    [InputType.Float, 1.25e10, { floatValue: 1.25e10 }],
-    [InputType.Float, '1.25e10', { floatValue: 1.25e10 }],
-    [InputType.Integer, 0, { integer: Long.fromNumber(0) }],
-    [InputType.Integer, Long.fromNumber(0), { integer: Long.fromNumber(0) }],
-    [InputType.Integer, '0', { integer: Long.fromNumber(0) }],
-    [InputType.Integer, 1, { integer: Long.fromNumber(1) }],
-    [InputType.Integer, Long.fromNumber(1), { integer: Long.fromNumber(1) }],
-    [InputType.Integer, '1', { integer: Long.fromNumber(1) }],
-    [InputType.Integer, -1, { integer: Long.fromNumber(-1) }],
-    [InputType.Integer, Long.fromNumber(-1), { integer: Long.fromNumber(-1) }],
-    [InputType.Integer, '-1', { integer: Long.fromNumber(-1) }],
-    [InputType.Integer, Long.MAX_VALUE.toString(), { integer: Long.MAX_VALUE }],
-    [InputType.Integer, Long.MAX_VALUE, { integer: Long.MAX_VALUE }],
-    [InputType.Integer, Long.MIN_VALUE.toString(), { integer: Long.MIN_VALUE }],
-    [InputType.Integer, Long.MIN_VALUE, { integer: Long.MIN_VALUE }],
-    [InputType.String, '', { stringValue: '' }],
-    [InputType.String, 'abcdefg', { stringValue: 'abcdefg' }]
+        primitiveLiteral({
+            datetime: dateToTimestamp(new Date(validDateString))
+        })
+    ],
+    [
+        InputType.Duration,
+        0,
+        primitiveLiteral({ duration: millisecondsToDuration(0) })
+    ],
+    [
+        InputType.Duration,
+        10000,
+        primitiveLiteral({ duration: millisecondsToDuration(10000) })
+    ],
+    [InputType.Float, 0, primitiveLiteral({ floatValue: 0 })],
+    [InputType.Float, '0', primitiveLiteral({ floatValue: 0 })],
+    [InputType.Float, -1.5, primitiveLiteral({ floatValue: -1.5 })],
+    [InputType.Float, '-1.5', primitiveLiteral({ floatValue: -1.5 })],
+    [InputType.Float, 1.5, primitiveLiteral({ floatValue: 1.5 })],
+    [InputType.Float, '1.5', primitiveLiteral({ floatValue: 1.5 })],
+    [InputType.Float, 1.25e10, primitiveLiteral({ floatValue: 1.25e10 })],
+    [InputType.Float, '1.25e10', primitiveLiteral({ floatValue: 1.25e10 })],
+    [InputType.Integer, 0, primitiveLiteral({ integer: Long.fromNumber(0) })],
+    [
+        InputType.Integer,
+        Long.fromNumber(0),
+        primitiveLiteral({ integer: Long.fromNumber(0) })
+    ],
+    [InputType.Integer, '0', primitiveLiteral({ integer: Long.fromNumber(0) })],
+    [InputType.Integer, 1, primitiveLiteral({ integer: Long.fromNumber(1) })],
+    [
+        InputType.Integer,
+        Long.fromNumber(1),
+        primitiveLiteral({ integer: Long.fromNumber(1) })
+    ],
+    [InputType.Integer, '1', primitiveLiteral({ integer: Long.fromNumber(1) })],
+    [InputType.Integer, -1, primitiveLiteral({ integer: Long.fromNumber(-1) })],
+    [
+        InputType.Integer,
+        Long.fromNumber(-1),
+        primitiveLiteral({ integer: Long.fromNumber(-1) })
+    ],
+    [
+        InputType.Integer,
+        '-1',
+        primitiveLiteral({ integer: Long.fromNumber(-1) })
+    ],
+    [
+        InputType.Integer,
+        Long.MAX_VALUE.toString(),
+        primitiveLiteral({ integer: Long.MAX_VALUE })
+    ],
+    [
+        InputType.Integer,
+        Long.MAX_VALUE,
+        primitiveLiteral({ integer: Long.MAX_VALUE })
+    ],
+    [
+        InputType.Integer,
+        Long.MIN_VALUE.toString(),
+        primitiveLiteral({ integer: Long.MIN_VALUE })
+    ],
+    [
+        InputType.Integer,
+        Long.MIN_VALUE,
+        primitiveLiteral({ integer: Long.MIN_VALUE })
+    ],
+    [InputType.String, '', primitiveLiteral({ stringValue: '' })],
+    [InputType.String, 'abcdefg', primitiveLiteral({ stringValue: 'abcdefg' })],
+    // Standard Blob
+    [
+        InputType.Blob,
+        {
+            uri: 's3://somePath',
+            format: 'csv',
+            dimensionality: BlobDimensionality.SINGLE
+        },
+        blobLiteral({
+            dimensionality: BlobDimensionality.SINGLE,
+            format: 'csv',
+            uri: 's3://somePath'
+        })
+    ],
+    // Multi-part blob
+    [
+        InputType.Blob,
+        {
+            dimensionality: BlobDimensionality.MULTIPART,
+            format: 'csv',
+            uri: 's3://somePath'
+        },
+        blobLiteral({
+            dimensionality: BlobDimensionality.MULTIPART,
+            format: 'csv',
+            uri: 's3://somePath'
+        })
+    ],
+    // Blob with missing format
+    [
+        InputType.Blob,
+        {
+            dimensionality: BlobDimensionality.SINGLE,
+            uri: 's3://somePath'
+        },
+        blobLiteral({
+            dimensionality: BlobDimensionality.SINGLE,
+            uri: 's3://somePath'
+        })
+    ],
+    // Blob with empty format string
+    [
+        InputType.Blob,
+        {
+            dimensionality: BlobDimensionality.SINGLE,
+            format: '',
+            uri: 's3://somePath'
+        },
+        blobLiteral({
+            dimensionality: BlobDimensionality.SINGLE,
+            uri: 's3://somePath'
+        })
+    ],
+    // Blobs using lowercase string for dimensionality
+    [
+        InputType.Blob,
+        {
+            dimensionality: 'single',
+            uri: 's3://somePath'
+        },
+        blobLiteral({
+            dimensionality: BlobDimensionality.SINGLE,
+            uri: 's3://somePath'
+        })
+    ],
+    [
+        InputType.Blob,
+        {
+            dimensionality: 'multipart',
+            uri: 's3://somePath'
+        },
+        blobLiteral({
+            dimensionality: BlobDimensionality.MULTIPART,
+            uri: 's3://somePath'
+        })
+    ],
+    // Blobs using uppercase string for dimensionality
+    [
+        InputType.Blob,
+        {
+            dimensionality: 'SINGLE',
+            uri: 's3://somePath'
+        },
+        blobLiteral({
+            dimensionality: BlobDimensionality.SINGLE,
+            uri: 's3://somePath'
+        })
+    ],
+    [
+        InputType.Blob,
+        {
+            dimensionality: 'MULTIPART',
+            uri: 's3://somePath'
+        },
+        blobLiteral({
+            dimensionality: BlobDimensionality.MULTIPART,
+            uri: 's3://somePath'
+        })
+    ],
+    // Blob missing URI (results in None)
+    [
+        InputType.Blob,
+        {
+            format: 'csv',
+            dimensionality: 'MULTIPART'
+        },
+        literalNone()
+    ],
+    // Blob which is not an object (results in None)
+    [InputType.Blob, undefined, literalNone()]
 ];
 
 type InputToLiteralTestParams = [
@@ -152,5 +365,72 @@ export const literalToInputTestCases: InputToLiteralTestParams[] = [
         Long.MIN_VALUE.toString()
     ],
     [InputType.String, primitiveLiteral({ stringValue: '' }), ''],
-    [InputType.String, primitiveLiteral({ stringValue: 'abcdefg' }), 'abcdefg']
+    [InputType.String, primitiveLiteral({ stringValue: 'abcdefg' }), 'abcdefg'],
+    // Standard Blob case
+    [
+        InputType.Blob,
+        blobLiteral({
+            dimensionality: BlobDimensionality.SINGLE,
+            format: 'csv',
+            uri: 's3://somePath'
+        }),
+        {
+            dimensionality: BlobDimensionality.SINGLE,
+            format: 'csv',
+            uri: 's3://somePath'
+        }
+    ],
+    // Multipart blob
+    [
+        InputType.Blob,
+        blobLiteral({
+            dimensionality: BlobDimensionality.MULTIPART,
+            format: 'csv',
+            uri: 's3://somePath'
+        }),
+        {
+            dimensionality: BlobDimensionality.MULTIPART,
+            format: 'csv',
+            uri: 's3://somePath'
+        }
+    ],
+    // Empty uri
+    [
+        InputType.Blob,
+        blobLiteral({
+            dimensionality: BlobDimensionality.SINGLE,
+            format: 'csv'
+        }),
+        {
+            dimensionality: BlobDimensionality.SINGLE,
+            format: 'csv',
+            uri: ''
+        }
+    ],
+    // Empty format string
+    [
+        InputType.Blob,
+        blobLiteral({
+            dimensionality: BlobDimensionality.SINGLE,
+            format: '',
+            uri: 's3://somePath'
+        }),
+        {
+            dimensionality: BlobDimensionality.SINGLE,
+            uri: 's3://somePath'
+        }
+    ],
+    // Missing dimensionality
+    [
+        InputType.Blob,
+        blobLiteral({
+            format: 'csv',
+            uri: 's3://somePath'
+        }),
+        {
+            dimensionality: BlobDimensionality.SINGLE,
+            format: 'csv',
+            uri: 's3://somePath'
+        }
+    ]
 ];
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/test/utils.test.ts b/src/components/Launch/LaunchWorkflowForm/inputHelpers/test/utils.test.ts
new file mode 100644
index 000000000..6671d9e00
--- /dev/null
+++ b/src/components/Launch/LaunchWorkflowForm/inputHelpers/test/utils.test.ts
@@ -0,0 +1,51 @@
+import { InputType, InputTypeDefinition } from '../../types';
+import { typeIsSupported } from '../utils';
+import { supportedPrimitives, unsupportedTypes } from './testCases';
+
+type TypeIsSupportedTestCase = [string, InputTypeDefinition, boolean];
+describe('Launch/inputHelpers/utils', () => {
+    describe('typeIsSupported', () => {
+        const cases: TypeIsSupportedTestCase[] = [
+            ...supportedPrimitives.map<TypeIsSupportedTestCase>(type => [
+                `supports type ${type}`,
+                { type },
+                true
+            ]),
+            ...supportedPrimitives.map<TypeIsSupportedTestCase>(type => [
+                `supports 1-dimension collection of type ${type}`,
+                { type: InputType.Collection, subtype: { type } },
+                true
+            ]),
+            ...supportedPrimitives.map<TypeIsSupportedTestCase>(type => [
+                `supports 2-dimension collection of type: ${type}`,
+                {
+                    type: InputType.Collection,
+                    subtype: { type: InputType.Collection, subtype: { type } }
+                },
+                true
+            ]),
+            ...unsupportedTypes.map<TypeIsSupportedTestCase>(type => [
+                `does NOT support type ${type}`,
+                { type },
+                false
+            ]),
+            ...unsupportedTypes.map<TypeIsSupportedTestCase>(type => [
+                `does NOT support 1-dimension collection of type ${type}`,
+                { type: InputType.Collection, subtype: { type } },
+                false
+            ]),
+            ...unsupportedTypes.map<TypeIsSupportedTestCase>(type => [
+                `does NOT support 2-dimension collection of type: ${type}`,
+                {
+                    type: InputType.Collection,
+                    subtype: { type: InputType.Collection, subtype: { type } }
+                },
+                false
+            ])
+        ];
+
+        cases.forEach(([description, value, expected]) =>
+            it(description, () => expect(typeIsSupported(value)).toBe(expected))
+        );
+    });
+});
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/types.ts b/src/components/Launch/LaunchWorkflowForm/inputHelpers/types.ts
index fb69991f9..7a471af4e 100644
--- a/src/components/Launch/LaunchWorkflowForm/inputHelpers/types.ts
+++ b/src/components/Launch/LaunchWorkflowForm/inputHelpers/types.ts
@@ -1,5 +1,5 @@
 import { Core } from 'flyteidl';
-import { InputTypeDefinition, InputValue } from '../types';
+import { InputProps, InputTypeDefinition, InputValue } from '../types';
 
 export interface ConverterInput {
     value: InputValue;
@@ -13,10 +13,18 @@ export type LiteralToInputConterterFn = (
     literal: Core.ILiteral,
     typeDefinition: InputTypeDefinition
 ) => InputValue | undefined;
+
+export type ValidationParams = Pick<
+    InputProps,
+    'initialValue' | 'name' | 'required' | 'typeDefinition' | 'value'
+>;
+
+export type InputValidatorParams = ValidationParams & { value: InputValue };
+
 export interface InputHelper {
     defaultValue?: InputValue;
     toLiteral: InputToLiteralConverterFn;
     fromLiteral: LiteralToInputConterterFn;
     /** Will throw in the case of a failed validation */
-    validate: (input: ConverterInput) => void;
+    validate: (params: InputValidatorParams) => void;
 }
diff --git a/src/components/Launch/LaunchWorkflowForm/inputHelpers/utils.ts b/src/components/Launch/LaunchWorkflowForm/inputHelpers/utils.ts
index 5b83a425a..f520127da 100644
--- a/src/components/Launch/LaunchWorkflowForm/inputHelpers/utils.ts
+++ b/src/components/Launch/LaunchWorkflowForm/inputHelpers/utils.ts
@@ -1,6 +1,8 @@
+import { assertNever } from 'common/utils';
 import { Core } from 'flyteidl';
 import { get } from 'lodash';
-import { InputType } from '../types';
+import { BlobDimensionality } from 'models';
+import { InputType, InputTypeDefinition } from '../types';
 
 /** Performs a deep get of `path` on the given `Core.ILiteral`. Will throw
  * if the given property doesn't exist.
@@ -25,3 +27,49 @@ export function collectionChildToString(type: InputType, value: any) {
     }
     return type === InputType.Integer ? `${value}` : JSON.stringify(value);
 }
+
+/** Determines if a given input type, including all levels of nested types, is
+ * supported for use in the Launch form.
+ */
+export function typeIsSupported(typeDefinition: InputTypeDefinition): boolean {
+    const { type, subtype } = typeDefinition;
+    switch (type) {
+        case InputType.Binary:
+        case InputType.Error:
+        case InputType.Map:
+        case InputType.None:
+        case InputType.Schema:
+        case InputType.Struct:
+        case InputType.Unknown:
+            return false;
+        case InputType.Boolean:
+        case InputType.Blob:
+        case InputType.Datetime:
+        case InputType.Duration:
+        case InputType.Float:
+        case InputType.Integer:
+        case InputType.String:
+            return true;
+        case InputType.Collection: {
+            if (!subtype) {
+                console.error(
+                    'Unexpected missing subtype for collection input',
+                    typeDefinition
+                );
+                return false;
+            }
+            return typeIsSupported(subtype);
+        }
+        default:
+            // This will cause a compiler error if new types are added and there is
+            // no case for them listed above.
+            assertNever(type, { noThrow: true });
+            return false;
+    }
+}
+
+export function isKeyOfBlobDimensionality(
+    value: string
+): value is keyof typeof BlobDimensionality {
+    return Object.keys(BlobDimensionality).indexOf(value) >= 0;
+}
diff --git a/src/components/Launch/LaunchWorkflowForm/styles.ts b/src/components/Launch/LaunchWorkflowForm/styles.ts
index 04a103395..50780d960 100644
--- a/src/components/Launch/LaunchWorkflowForm/styles.ts
+++ b/src/components/Launch/LaunchWorkflowForm/styles.ts
@@ -14,7 +14,6 @@ export const useStyles = makeStyles((theme: Theme) => ({
         width: '100%'
     },
     inputsSection: {
-        minHeight: theme.spacing(59),
         padding: theme.spacing(2)
     },
     inputLabel: {
diff --git a/src/components/Launch/LaunchWorkflowForm/test/LaunchWorkflowForm.test.tsx b/src/components/Launch/LaunchWorkflowForm/test/LaunchWorkflowForm.test.tsx
index 6ffaa7d65..1af974586 100644
--- a/src/components/Launch/LaunchWorkflowForm/test/LaunchWorkflowForm.test.tsx
+++ b/src/components/Launch/LaunchWorkflowForm/test/LaunchWorkflowForm.test.tsx
@@ -34,13 +34,19 @@ import * as React from 'react';
 import { delayedPromise, pendingPromise } from 'test/utils';
 import {
     createMockWorkflowInputsInterface,
-    mockSimpleVariables
+    mockSimpleVariables,
+    simpleVariableDefaults
 } from '../__mocks__/mockInputs';
-import { formStrings } from '../constants';
+import {
+    cannotLaunchWorkflowString,
+    formStrings,
+    requiredInputSuffix
+} from '../constants';
 import { LaunchWorkflowForm } from '../LaunchWorkflowForm';
 import { InitialLaunchParameters, LaunchWorkflowFormProps } from '../types';
 import { createInputCacheKey, getInputDefintionForLiteralType } from '../utils';
 import {
+    binaryInputName,
     booleanInputName,
     integerInputName,
     stringInputName,
@@ -748,4 +754,80 @@ describe('LaunchWorkflowForm', () => {
             });
         });
     });
+
+    describe('With Unsupported Required Inputs', () => {
+        beforeEach(() => {
+            variables = mockSimpleVariables;
+            createMocks();
+            // Binary is currently unsupported, setting the binary input to
+            // required and removing the default value will trigger our use case
+            const parameters = mockLaunchPlans[0].closure!.expectedInputs
+                .parameters;
+            parameters[binaryInputName].required = true;
+            delete parameters[binaryInputName].default;
+            mockGetLaunchPlan.mockResolvedValue(mockLaunchPlans[0]);
+        });
+
+        it('should render error message', async () => {
+            const { getByText } = renderForm();
+            const errorElement = await waitFor(() =>
+                getByText(cannotLaunchWorkflowString)
+            );
+            expect(errorElement).toBeInTheDocument();
+        });
+
+        it('should show unsupported inputs', async () => {
+            const { getByText } = renderForm();
+            const inputElement = await waitFor(() =>
+                getByText(binaryInputName, { exact: false })
+            );
+            expect(inputElement).toBeInTheDocument();
+        });
+
+        it('should print input labels without decoration', async () => {
+            const { getByText } = renderForm();
+            const inputElement = await waitFor(() =>
+                getByText(binaryInputName, { exact: false })
+            );
+            expect(inputElement.textContent).not.toContain(requiredInputSuffix);
+        });
+
+        it('should disable submission', async () => {
+            const { getByRole } = renderForm();
+
+            const submitButton = await waitFor(() =>
+                getByRole('button', { name: formStrings.submit })
+            );
+
+            expect(submitButton).toBeDisabled();
+        });
+
+        it('should not show error if launch plan has default value', async () => {
+            mockLaunchPlans[0].closure!.expectedInputs.parameters[
+                binaryInputName
+            ].default = simpleVariableDefaults.simpleBinary as Literal;
+            const { queryByText } = renderForm();
+            await waitFor(() => queryByText(binaryInputName, { exact: false }));
+            expect(queryByText(cannotLaunchWorkflowString)).toBeNull();
+        });
+
+        it('should not show error if initial value is provided', async () => {
+            const parameters = mockLaunchPlans[0].closure!.expectedInputs
+                .parameters;
+            const values = new Map();
+            const cacheKey = createInputCacheKey(
+                binaryInputName,
+                getInputDefintionForLiteralType(
+                    parameters[binaryInputName].var.type
+                )
+            );
+            values.set(cacheKey, simpleVariableDefaults.simpleBinary);
+            const { queryByText } = renderForm({
+                initialParameters: { values }
+            });
+
+            await waitFor(() => queryByText(binaryInputName, { exact: false }));
+            expect(queryByText(cannotLaunchWorkflowString)).toBeNull();
+        });
+    });
 });
diff --git a/src/components/Launch/LaunchWorkflowForm/test/constants.ts b/src/components/Launch/LaunchWorkflowForm/test/constants.ts
index ea11fce8e..1c7df2799 100644
--- a/src/components/Launch/LaunchWorkflowForm/test/constants.ts
+++ b/src/components/Launch/LaunchWorkflowForm/test/constants.ts
@@ -2,3 +2,5 @@ export const booleanInputName = 'simpleBoolean';
 export const stringInputName = 'simpleString';
 export const stringNoLabelName = 'stringNoLabel';
 export const integerInputName = 'simpleInteger';
+export const binaryInputName = 'simpleBinary';
+export const errorInputName = 'simpleError';
diff --git a/src/components/Launch/LaunchWorkflowForm/types.ts b/src/components/Launch/LaunchWorkflowForm/types.ts
index 4ebd81834..e92e5d4e6 100644
--- a/src/components/Launch/LaunchWorkflowForm/types.ts
+++ b/src/components/Launch/LaunchWorkflowForm/types.ts
@@ -1,6 +1,8 @@
 import { FetchableData, MultiFetchableState } from 'components/hooks';
 import { Core } from 'flyteidl';
+import { isObject } from 'lodash';
 import {
+    BlobDimensionality,
     Identifier,
     LaunchPlan,
     NamedEntityIdentifier,
@@ -42,6 +44,7 @@ export interface LaunchWorkflowFormState {
     selectedWorkflow?: SearchableSelectorOption<WorkflowId>;
     showErrors: boolean;
     submissionState: FetchableData<WorkflowExecutionIdentifier>;
+    unsupportedRequiredInputs: ParsedInput[];
     workflowName: string;
     workflowOptionsLoadingState: MultiFetchableState;
     workflowSelectorOptions: SearchableSelectorOption<WorkflowId>[];
@@ -74,7 +77,17 @@ export interface InputTypeDefinition {
     subtype?: InputTypeDefinition;
 }
 
-export type InputValue = string | number | boolean | Date;
+export interface ObjectValue {
+    type: InputType;
+}
+
+export interface BlobValue {
+    dimensionality: BlobDimensionality | string;
+    format?: string;
+    uri: string;
+}
+
+export type InputValue = string | number | boolean | Date | BlobValue;
 export type InputChangeHandler = (newValue: InputValue) => void;
 
 export interface InputProps {
diff --git a/src/components/Launch/LaunchWorkflowForm/useLaunchWorkflowFormState.ts b/src/components/Launch/LaunchWorkflowForm/useLaunchWorkflowFormState.ts
index e5263759d..1ac2741f7 100644
--- a/src/components/Launch/LaunchWorkflowForm/useLaunchWorkflowFormState.ts
+++ b/src/components/Launch/LaunchWorkflowForm/useLaunchWorkflowFormState.ts
@@ -30,6 +30,7 @@ import {
     ParsedInput
 } from './types';
 import {
+    getUnsupportedRequiredInputs,
     launchPlansToSearchableSelectorOptions,
     workflowsToSearchableSelectorOptions
 } from './utils';
@@ -248,6 +249,11 @@ export function useLaunchWorkflowFormState({
 
     const [parsedInputs, setParsedInputs] = useState<ParsedInput[]>([]);
 
+    const unsupportedRequiredInputs = useMemo(
+        () => getUnsupportedRequiredInputs(parsedInputs),
+        [parsedInputs]
+    );
+
     // Any time the inputs change (even if it's just re-ordering), we must
     // change the form key so that the inputs component will re-mount.
     const formKey = useMemo<string>(() => {
@@ -421,6 +427,7 @@ export function useLaunchWorkflowFormState({
         selectedWorkflow,
         showErrors,
         submissionState,
+        unsupportedRequiredInputs,
         workflowName,
         workflowOptionsLoadingState,
         workflowSelectorOptions,
diff --git a/src/components/Launch/LaunchWorkflowForm/utils.ts b/src/components/Launch/LaunchWorkflowForm/utils.ts
index 457adcc0d..2434b0210 100644
--- a/src/components/Launch/LaunchWorkflowForm/utils.ts
+++ b/src/components/Launch/LaunchWorkflowForm/utils.ts
@@ -1,5 +1,6 @@
 import { timestampToDate } from 'common/utils';
 import { Core } from 'flyteidl';
+import { isObject } from 'lodash';
 import {
     LaunchPlan,
     LiteralType,
@@ -10,8 +11,15 @@ import {
 import * as moment from 'moment';
 import { simpleTypeToInputType, typeLabels } from './constants';
 import { inputToLiteral } from './inputHelpers/inputHelpers';
+import { typeIsSupported } from './inputHelpers/utils';
 import { SearchableSelectorOption } from './SearchableSelector';
-import { InputProps, InputType, InputTypeDefinition } from './types';
+import {
+    BlobValue,
+    InputProps,
+    InputType,
+    InputTypeDefinition,
+    ParsedInput
+} from './types';
 
 /** Creates a unique cache key for an input based on its name and type.
  * Note: This will not be *globally* unique, only unique within a single workflow
@@ -152,3 +160,21 @@ export function getInputDefintionForLiteralType(
 export function getLaunchInputId(name: string): string {
     return `launch-input-${name}`;
 }
+
+/** Given an array of `ParsedInput`s, returns the subset which are required
+ * and of a type which cannot be provided via our form.
+ */
+export function getUnsupportedRequiredInputs(
+    inputs: ParsedInput[]
+): ParsedInput[] {
+    return inputs.filter(
+        input =>
+            !typeIsSupported(input.typeDefinition) &&
+            input.required &&
+            input.initialValue === undefined
+    );
+}
+
+export function isBlobValue(value: unknown): value is BlobValue {
+    return isObject(value);
+}
diff --git a/src/components/Theme/constants.ts b/src/components/Theme/constants.ts
index 67861b961..a2574ca61 100644
--- a/src/components/Theme/constants.ts
+++ b/src/components/Theme/constants.ts
@@ -24,7 +24,7 @@ export const mutedPrimaryTextColor = '#4A4A4A';
 export const tableHeaderColor = COLOR_SPECTRUM.gray40.color;
 export const tablePlaceholderColor = COLOR_SPECTRUM.gray40.color;
 
-export const selectedActionColor = primaryColor;
+export const selectedActionColor = COLOR_SPECTRUM.gray10.color;
 
 export const warningHighlightColor = COLOR_SPECTRUM.sunset50.color;
 export const cautionHighlightColor = COLOR_SPECTRUM.amber50.color;
diff --git a/src/models/Common/types.ts b/src/models/Common/types.ts
index ee970a86b..92765a352 100644
--- a/src/models/Common/types.ts
+++ b/src/models/Common/types.ts
@@ -68,6 +68,13 @@ export interface Literal extends Core.Literal {
     scalar?: Scalar;
 }
 
+/** A Core.ILiteral guaranteed to have all subproperties necessary to specify
+ * a Blob.
+ */
+export interface BlobLiteral extends Core.ILiteral {
+    scalar: BlobScalar;
+}
+
 export interface LiteralCollection
     extends RequiredNonNullable<Core.ILiteralCollection> {}
 
@@ -81,6 +88,9 @@ export interface Scalar extends Core.IScalar {
     primitive?: Primitive;
     value: keyof Core.IScalar;
 }
+export interface BlobScalar extends Core.IScalar {
+    blob: Blob;
+}
 
 export interface Schema extends Core.ISchema {
     uri: string;
diff --git a/yarn.lock b/yarn.lock
index 169e28285..06aa8a517 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -4082,7 +4082,7 @@ ajv-keywords@^3.1.0, ajv-keywords@^3.4.1:
   resolved "https://registry.yarnpkg.com/ajv-keywords/-/ajv-keywords-3.5.0.tgz#5c894537098785926d71e696114a53ce768ed773"
   integrity sha512-eyoaac3btgU8eJlvh01En8OCKzRqlLe2G5jDsCr3RiE2uLGMEEB1aaGwVVpwR8M95956tGH6R+9edC++OvzaVw==
 
-ajv@^6.1.0, ajv@^6.1.1, ajv@^6.10.2, ajv@^6.12.2, ajv@^6.5.5, ajv@^6.9.1:
+ajv@^6.1.0, ajv@^6.1.1, ajv@^6.10.2, ajv@^6.12.2, ajv@^6.9.1:
   version "6.12.2"
   resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.2.tgz#c629c5eced17baf314437918d2da88c99d5958cd"
   integrity sha512-k+V+hzjm5q/Mr8ef/1Y9goCmlsK4I6Sm74teeyGvFk1XrOsbsKLjEdrvny42CZ+a8sXbk8KWpY/bDwS+FLL2UQ==
@@ -4092,6 +4092,16 @@ ajv@^6.1.0, ajv@^6.1.1, ajv@^6.10.2, ajv@^6.12.2, ajv@^6.5.5, ajv@^6.9.1:
     json-schema-traverse "^0.4.1"
     uri-js "^4.2.2"
 
+ajv@^6.5.5:
+  version "6.12.3"
+  resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.3.tgz#18c5af38a111ddeb4f2697bd78d68abc1cabd706"
+  integrity sha512-4K0cK3L1hsqk9xIb2z9vs/XU+PGJZ9PNpJRDS9YLzmNdX6jmVPfamLvTJr0aDAusnHyCHO6MjzlkAsgtqp9teA==
+  dependencies:
+    fast-deep-equal "^3.1.1"
+    fast-json-stable-stringify "^2.0.0"
+    json-schema-traverse "^0.4.1"
+    uri-js "^4.2.2"
+
 ansi-align@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/ansi-align/-/ansi-align-2.0.0.tgz#c36aeccba563b89ceb556f3690f0b1d9e3547f7f"
@@ -6646,7 +6656,7 @@ debug@^3.0.0, debug@^3.1.0, debug@^3.2.5:
   dependencies:
     ms "^2.1.1"
 
-debuglog@^1.0.1:
+debuglog@*, debuglog@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/debuglog/-/debuglog-1.0.1.tgz#aa24ffb9ac3df9a2351837cfb2d279360cd78492"
   integrity sha1-qiT/uaw9+aI1GDfPstJ5NgzXhJI=
@@ -9163,7 +9173,7 @@ import-local@^3.0.2:
     pkg-dir "^4.2.0"
     resolve-cwd "^3.0.0"
 
-imurmurhash@^0.1.4:
+imurmurhash@*, imurmurhash@^0.1.4:
   version "0.1.4"
   resolved "https://registry.yarnpkg.com/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea"
   integrity sha1-khi5srkoojixPcT7a21XbyMUU+o=
@@ -11002,6 +11012,11 @@ lodash._basecopy@^3.0.0:
   resolved "https://registry.yarnpkg.com/lodash._basecopy/-/lodash._basecopy-3.0.1.tgz#8da0e6a876cf344c0ad8a54882111dd3c5c7ca36"
   integrity sha1-jaDmqHbPNEwK2KVIghEd08XHyjY=
 
+lodash._baseindexof@*:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/lodash._baseindexof/-/lodash._baseindexof-3.1.0.tgz#fe52b53a1c6761e42618d654e4a25789ed61822c"
+  integrity sha1-/lK1OhxnYeQmGNZU5KJXie1hgiw=
+
 lodash._baseuniq@~4.6.0:
   version "4.6.0"
   resolved "https://registry.yarnpkg.com/lodash._baseuniq/-/lodash._baseuniq-4.6.0.tgz#0ebb44e456814af7905c6212fa2c9b2d51b841e8"
@@ -11010,11 +11025,16 @@ lodash._baseuniq@~4.6.0:
     lodash._createset "~4.0.0"
     lodash._root "~3.0.0"
 
-lodash._bindcallback@^3.0.0:
+lodash._bindcallback@*, lodash._bindcallback@^3.0.0:
   version "3.0.1"
   resolved "https://registry.yarnpkg.com/lodash._bindcallback/-/lodash._bindcallback-3.0.1.tgz#e531c27644cf8b57a99e17ed95b35c748789392e"
   integrity sha1-5THCdkTPi1epnhftlbNcdIeJOS4=
 
+lodash._cacheindexof@*:
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/lodash._cacheindexof/-/lodash._cacheindexof-3.0.2.tgz#3dc69ac82498d2ee5e3ce56091bafd2adc7bde92"
+  integrity sha1-PcaayCSY0u5ePOVgkbr9Ktx73pI=
+
 lodash._createassigner@^3.0.0:
   version "3.1.1"
   resolved "https://registry.yarnpkg.com/lodash._createassigner/-/lodash._createassigner-3.1.1.tgz#838a5bae2fdaca63ac22dee8e19fa4e6d6970b11"
@@ -11024,12 +11044,19 @@ lodash._createassigner@^3.0.0:
     lodash._isiterateecall "^3.0.0"
     lodash.restparam "^3.0.0"
 
+lodash._createcache@*:
+  version "3.1.2"
+  resolved "https://registry.yarnpkg.com/lodash._createcache/-/lodash._createcache-3.1.2.tgz#56d6a064017625e79ebca6b8018e17440bdcf093"
+  integrity sha1-VtagZAF2JeeevKa4AY4XRAvc8JM=
+  dependencies:
+    lodash._getnative "^3.0.0"
+
 lodash._createset@~4.0.0:
   version "4.0.3"
   resolved "https://registry.yarnpkg.com/lodash._createset/-/lodash._createset-4.0.3.tgz#0f4659fbb09d75194fa9e2b88a6644d363c9fe26"
   integrity sha1-D0ZZ+7CddRlPqeK4imZE02PJ/iY=
 
-lodash._getnative@^3.0.0:
+lodash._getnative@*, lodash._getnative@^3.0.0:
   version "3.9.1"
   resolved "https://registry.yarnpkg.com/lodash._getnative/-/lodash._getnative-3.9.1.tgz#570bc7dede46d61cdcde687d65d3eecbaa3aaff5"
   integrity sha1-VwvH3t5G1hzc3mh9ZdPuy6o6r/U=
@@ -11150,7 +11177,7 @@ lodash.memoize@4.x, lodash.memoize@^4.1.2:
   resolved "https://registry.yarnpkg.com/lodash.memoize/-/lodash.memoize-4.1.2.tgz#bcc6c49a42a2840ed997f323eada5ecd182e0bfe"
   integrity sha1-vMbEmkKihA7Zl/Mj6tpezRguC/4=
 
-lodash.restparam@^3.0.0:
+lodash.restparam@*, lodash.restparam@^3.0.0:
   version "3.6.1"
   resolved "https://registry.yarnpkg.com/lodash.restparam/-/lodash.restparam-3.6.1.tgz#936a4e309ef330a7645ed4145986c85ae5b20805"
   integrity sha1-k2pOMJ7zMKdkXtQUWYbIWuWyCAU=
@@ -12225,10 +12252,10 @@ npm-profile@^4.0.2, npm-profile@^4.0.4:
     figgy-pudding "^3.4.1"
     npm-registry-fetch "^4.0.0"
 
-npm-registry-fetch@^4.0.0, npm-registry-fetch@^4.0.4:
-  version "4.0.4"
-  resolved "https://registry.yarnpkg.com/npm-registry-fetch/-/npm-registry-fetch-4.0.4.tgz#2da1ecf3f43d419d96abf313664291a4623d3ea5"
-  integrity sha512-6jb34hX/iYNQebqWUHtU8YF6Cjb1H6ouTFPClYsyiW6lpFkljTpdeftm53rRojtja1rKAvKNIIiTS5Sjpw4wsA==
+npm-registry-fetch@^4.0.0, npm-registry-fetch@^4.0.5:
+  version "4.0.5"
+  resolved "https://registry.yarnpkg.com/npm-registry-fetch/-/npm-registry-fetch-4.0.5.tgz#cb87cf7f25bfb048d6c3ee19d115bebf93ea5bfa"
+  integrity sha512-yQ0/U4fYpCCqmueB2g8sc+89ckQ3eXpmU4+Yi2j5o/r0WkKvE2+Y0tK3DEILAtn2UaQTkjTHxIXe2/CSdit+/Q==
   dependencies:
     JSONStream "^1.3.4"
     bluebird "^3.5.1"
@@ -12267,9 +12294,9 @@ npm-which@^3.0.1:
     which "^1.2.10"
 
 npm@^6.10.3:
-  version "6.14.5"
-  resolved "https://registry.yarnpkg.com/npm/-/npm-6.14.5.tgz#2cc59a3158cdd8461b486d0584c74ab554567219"
-  integrity sha512-CDwa3FJd0XJpKDbWCST484H+mCNjF26dPrU+xnREW+upR0UODjMEfXPl3bxWuAwZIX6c2ASg1plLO7jP8ehWeA==
+  version "6.14.6"
+  resolved "https://registry.yarnpkg.com/npm/-/npm-6.14.6.tgz#1a81ce1fac2bf5457dbf6342ceed503627ff228f"
+  integrity sha512-axnz6iHFK6WPE0js/+mRp+4IOwpHn5tJEw5KB6FiCU764zmffrhsYHbSHi2kKqNkRBt53XasXjngZfBD3FQzrQ==
   dependencies:
     JSONStream "^1.3.5"
     abbrev "~1.1.1"
@@ -12289,6 +12316,7 @@ npm@^6.10.3:
     cmd-shim "^3.0.3"
     columnify "~1.5.4"
     config-chain "^1.1.12"
+    debuglog "*"
     detect-indent "~5.0.0"
     detect-newline "^2.1.0"
     dezalgo "~1.0.3"
@@ -12303,6 +12331,7 @@ npm@^6.10.3:
     has-unicode "~2.0.1"
     hosted-git-info "^2.8.8"
     iferr "^1.0.2"
+    imurmurhash "*"
     infer-owner "^1.0.4"
     inflight "~1.0.6"
     inherits "^2.0.4"
@@ -12321,8 +12350,14 @@ npm@^6.10.3:
     libnpx "^10.2.2"
     lock-verify "^2.1.0"
     lockfile "^1.0.4"
+    lodash._baseindexof "*"
     lodash._baseuniq "~4.6.0"
+    lodash._bindcallback "*"
+    lodash._cacheindexof "*"
+    lodash._createcache "*"
+    lodash._getnative "*"
     lodash.clonedeep "~4.5.0"
+    lodash.restparam "*"
     lodash.union "~4.6.0"
     lodash.uniq "~4.5.0"
     lodash.without "~4.4.0"
@@ -12342,7 +12377,7 @@ npm@^6.10.3:
     npm-packlist "^1.4.8"
     npm-pick-manifest "^3.0.2"
     npm-profile "^4.0.4"
-    npm-registry-fetch "^4.0.4"
+    npm-registry-fetch "^4.0.5"
     npm-user-validate "~1.0.0"
     npmlog "~4.1.2"
     once "~1.4.0"