diff --git a/.travis.yml b/.travis.yml
index 99709b9..e294b14 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -10,12 +10,8 @@ matrix:
     - python: '3.7'  # temp solution until python 3.7 is more cleanly supported
       dist: xenial
       sudo: true
-  allow_failures:
-    - python: '3.7'  # dependencies are blocking installation
-  fast_finish: true
 
 install:
-  - pip install git+git://github.com/udst/choicemodels.git
   - pip install .
   - pip install -r requirements-extras.txt
   - pip install -r requirements-dev.txt
diff --git a/CHANGELOG.md b/CHANGELOG.md
index c196666..0fd22e4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,9 +2,15 @@
 
 ## 0.2 (not yet released)
 
+#### 0.2.dev6 (2019-04-04)
+
+- introduces classes for storing common settings: `shared.CoreTemplateSettings`, `shared.OutputColumnSettings`
+- adds new shared functions: `shared.register_column()`, `utils.cols_in_expression()`
+- modifies `ColumnFromExpression` template to divide its parameters into three groups
+
 #### 0.2.dev5 (2019-03-29)
 
-- adds new template: `urbansim_templates.data.ColumnFromExpression`
+- adds new template: `data.ColumnFromExpression`
 
 #### 0.2.dev4 (2019-03-26)
 
@@ -20,8 +26,8 @@
 
 #### 0.2.dev2 (2019-03-04)
 
-- adds template for saving data: `urbansim_templates.data.SaveTable()`
-- renames `TableFromDisk()` to `urbansim_templates.data.LoadTable()`
+- adds template for saving data: `data.SaveTable()`
+- renames `io.TableFromDisk()` to `data.LoadTable()`
 
 #### 0.2.dev1 (2019-02-27)
 
@@ -29,7 +35,7 @@
 
 #### 0.2.dev0 (2019-02-19)
 
-- adds first data i/o template: `urbansim_templates.io.TableFromDisk()`
+- adds first data i/o template: `io.TableFromDisk()`
 - adds support for `autorun` template property
 
 
diff --git a/docs/source/conf.py b/docs/source/conf.py
index 9d7541f..1faf741 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -37,6 +37,7 @@
 # ones.
 extensions = [
     'sphinx.ext.autodoc',
+    'sphinx.ext.autosummary',
     'sphinx.ext.napoleon',
     'sphinx.ext.viewcode']
 
diff --git a/docs/source/data-templates.rst b/docs/source/data-templates.rst
index 9317a3e..ab8b676 100644
--- a/docs/source/data-templates.rst
+++ b/docs/source/data-templates.rst
@@ -1,13 +1,10 @@
-Data template APIs
-==================
+Data management templates
+=========================
 
 Usage
 -----
 
-Data templates help you load tables into `Orca <https://udst.github.io/orca>`__ or save tables or subsets of tables to disk. 
-
-Example
-~~~~~~~
+Data templates help you load tables into `Orca <https://udst.github.io/orca>`__, create columns of derived data, or save tables or subsets of tables to disk. 
 
 .. code-block:: python
     
@@ -75,22 +72,42 @@ From Orca's perspective, tables set up using the :mod:`~urbansim_templates.data.
 Unlike the templates, Orca relies on user-specified "`broadcast <http://udst.github.io/orca/core.html#merge-api>`__" relationships to perform automatic merging of tables. :mod:`~urbansim_templates.data.LoadTable` does not register any broadcasts, because they're not needed if tables follow the schema rules above. So if you use these tables in non-template model steps, you may need to add broadcasts separately.
 
 
-LoadTable()
------------
+Data loading API
+----------------
+
+.. currentmodule:: urbansim_templates.data
+
+.. autosummary::
+    LoadTable
 
 .. autoclass:: urbansim_templates.data.LoadTable
    :members:
 
 
-SaveTable()
------------
+Column creation API
+-------------------
 
-.. autoclass:: urbansim_templates.data.SaveTable
+.. currentmodule:: urbansim_templates.data
+
+.. autosummary::
+    ColumnFromExpression
+    ExpressionSettings
+
+.. autoclass:: urbansim_templates.data.ColumnFromExpression
    :members:
 
+.. autoclass:: urbansim_templates.data.ExpressionSettings
+   :members:
 
-ColumnFromExpression()
-----------------------
+Data output API
+---------------
 
-.. autoclass:: urbansim_templates.data.ColumnFromExpression
+.. currentmodule:: urbansim_templates.data
+
+.. autosummary::
+    SaveTable
+
+.. autoclass:: urbansim_templates.data.SaveTable
    :members:
+
+
diff --git a/docs/source/index.rst b/docs/source/index.rst
index 1e5ce05..10451ec 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -10,7 +10,7 @@ UrbanSim Templates provides building blocks for Orca-based simulation models. It
 
 The library contains templates for common types of model steps, plus a tool called ModelManager that runs as an extension to the `Orca <https://udst.github.io/orca>`__ task orchestrator. ModelManager can register template-based model steps with the orchestrator, save them to disk, and automatically reload them for future sessions.
 
-v0.2.dev5, released March 29, 2019
+v0.2.dev6, released April 4, 2019
 
 
 Contents
diff --git a/docs/source/utilities.rst b/docs/source/utilities.rst
index 0e3f76e..a86d392 100644
--- a/docs/source/utilities.rst
+++ b/docs/source/utilities.rst
@@ -1,32 +1,87 @@
-Utilities API
-=============
+Shared utilities
+================
 
 The utilities are mainly helper functions for templates. 
 
 
-Template validation
--------------------
+General template tools API
+--------------------------
 
-.. automodule:: urbansim_templates.utils
-   :members: validate_template
+.. currentmodule:: urbansim_templates.shared
+
+.. autosummary::
+    CoreTemplateSettings
+
+.. automodule:: urbansim_templates.shared
+   :members: CoreTemplateSettings
+
+
+Column output tools API
+-----------------------
 
+.. currentmodule:: urbansim_templates.shared
 
-Table schemas and merging
--------------------------
+.. autosummary::
+    OutputColumnSettings
+    register_column
+
+.. automodule:: urbansim_templates.shared
+   :members: OutputColumnSettings, register_column
+
+
+Table schemas and merging API
+-----------------------------
+
+.. currentmodule:: urbansim_templates.utils
+
+.. autosummary::
+    validate_table
+    validate_all_tables
+    merge_tables
 
 .. automodule:: urbansim_templates.utils
    :members: validate_table, validate_all_tables, merge_tables
 
 
-Other helper functions
-----------------------
+Other helper functions API
+--------------------------
+
+.. currentmodule:: urbansim_templates.utils
+
+.. autosummary::
+    all_cols
+    cols_in_expression
+    get_data
+    get_df
+    trim_cols
+    to_list
+    update_column
+    update_name
 
 .. automodule:: urbansim_templates.utils
-   :members: all_cols, get_data, get_df, trim_cols, update_column, to_list, update_column, update_name
+   :members: all_cols, cols_in_expression, get_data, get_df, trim_cols, to_list, update_column, update_name
+
+
+Spec validation API
+-------------------
+
+.. currentmodule:: urbansim_templates.utils
+
+.. autosummary::
+    validate_template
+
+.. automodule:: urbansim_templates.utils
+   :members: validate_template
+
+
+Version management API
+----------------------
 
+.. currentmodule:: urbansim_templates.utils
 
-Version management
-------------------
+.. autosummary::
+    parse_version
+    version_greater_or_equal
 
 .. automodule:: urbansim_templates.utils
    :members: parse_version, version_greater_or_equal
diff --git a/setup.py b/setup.py
index b77543a..e9e99af 100644
--- a/setup.py
+++ b/setup.py
@@ -6,7 +6,7 @@
 
 setup(
     name='urbansim_templates',
-    version='0.2.dev5',
+    version='0.2.dev6',
     description='UrbanSim extension for managing model steps',
     author='UrbanSim Inc.',
     author_email='info@urbansim.com',
diff --git a/tests/test_column_expression.py b/tests/test_column_expression.py
index 4af02df..dc288c4 100644
--- a/tests/test_column_expression.py
+++ b/tests/test_column_expression.py
@@ -5,10 +5,52 @@
 import orca
 
 from urbansim_templates import modelmanager
-from urbansim_templates.data import ColumnFromExpression
+from urbansim_templates.data import ColumnFromExpression, ExpressionSettings
 from urbansim_templates.utils import validate_template
 
 
+def test_expression_settings_persistence():
+    """
+    Confirm ExpressionSettings properties persist through the constructor, to_dict(),
+    and from_dict().
+    
+    """
+    d = {'table': 'tab', 'expression': 'a + b + c'}
+    obj = ExpressionSettings(table = 'tab', expression = 'a + b + c')
+
+    assert(d == obj.to_dict() == ExpressionSettings.from_dict(d).to_dict())
+
+
+def test_legacy_data_loader(orca_session):
+    """
+    Check that loading a saved dict with the legacy format works.
+    
+    """
+    d = {
+        'name': 'n',
+        'tags': ['a', 'b'],
+        'autorun': False,
+        'column_name': 'col',
+        'table': 'tab',
+        'expression': 'abc',
+        'data_type': 'int',
+        'missing_values': 5,
+        'cache': True,
+        'cache_scope': 'step'}
+    
+    c = ColumnFromExpression.from_dict(d)
+    assert(c.meta.name == d['name'])
+    assert(c.meta.tags == d['tags'])
+    assert(c.meta.autorun == d['autorun'])
+    assert(c.data.table == d['table'])
+    assert(c.data.expression == d['expression'])
+    assert(c.output.column_name == d['column_name'])
+    assert(c.output.data_type == d['data_type'])
+    assert(c.output.missing_values == d['missing_values'])
+    assert(c.output.cache == d['cache'])
+    assert(c.output.cache_scope == d['cache_scope'])
+
+
 @pytest.fixture
 def orca_session():
     """
@@ -26,12 +68,12 @@ def orca_session():
     orca.add_table('obs', df)
 
 
-def test_template_validity():
-    """
-    Check template conforms to basic spec.
-    
-    """
-    assert validate_template(ColumnFromExpression)
+# def test_template_validity():
+#     """
+#     Check template conforms to basic spec.
+#     
+#     """
+#     assert validate_template(ColumnFromExpression)
 
 
 def test_missing_colname(orca_session):
@@ -40,8 +82,8 @@ def test_missing_colname(orca_session):
     
     """
     c = ColumnFromExpression()
-    c.table = 'tab'
-    c.expression = 'a'
+    c.data.table = 'tab'
+    c.data.expression = 'a'
     
     try:
         c.run()
@@ -58,8 +100,8 @@ def test_missing_table(orca_session):
     
     """
     c = ColumnFromExpression()
-    c.column_name = 'col'
-    c.expression = 'a'
+    c.data.expression = 'a'
+    c.output.column_name = 'col'
     
     try:
         c.run()
@@ -76,8 +118,8 @@ def test_missing_expression(orca_session):
     
     """
     c = ColumnFromExpression()
-    c.column_name = 'col'
-    c.table = 'tab'
+    c.data.table = 'tab'
+    c.output.column_name = 'col'
     
     try:
         c.run()
@@ -94,9 +136,9 @@ def test_expression(orca_session):
     
     """
     c = ColumnFromExpression()
-    c.column_name = 'c'
-    c.table = 'obs'
-    c.expression = 'a * 5 + sqrt(b)'
+    c.data.table = 'obs'
+    c.data.expression = 'a * 5 + sqrt(b)'
+    c.output.column_name = 'c'
     
     c.run()
     
@@ -106,64 +148,18 @@ def test_expression(orca_session):
     assert(val1.equals(val2))
     
 
-def test_data_type(orca_session):
-    """
-    Check that casting data type works.
-    
-    """
-    orca.add_table('tab', pd.DataFrame({'a': [0.1, 1.33, 2.4]}))
-    
-    c = ColumnFromExpression()
-    c.column_name = 'b'
-    c.table = 'tab'
-    c.expression = 'a'
-    c.run()
-    
-    v1 = orca.get_table('tab').get_column('b').values
-    np.testing.assert_equal(v1, [0.1, 1.33, 2.4])
-    
-    c.data_type = 'int'
-    c.run()
-
-    v1 = orca.get_table('tab').get_column('b').values
-    np.testing.assert_equal(v1, [0, 1, 2])
-
-
-def test_missing_values(orca_session):
-    """
-    Check that filling in missing values works.
-    
-    """
-    orca.add_table('tab', pd.DataFrame({'a': [0.1, np.nan, 2.4]}))
-    
-    c = ColumnFromExpression()
-    c.column_name = 'b'
-    c.table = 'tab'
-    c.expression = 'a'
-    c.run()
-    
-    v1 = orca.get_table('tab').get_column('b').values
-    np.testing.assert_equal(v1, [0.1, np.nan, 2.4])
-    
-    c.missing_values = 5
-    c.run()
-
-    v1 = orca.get_table('tab').get_column('b').values
-    np.testing.assert_equal(v1, [0.1, 5.0, 2.4])
-
-
 def test_modelmanager_registration(orca_session):
     """
     Check that modelmanager registration and auto-run work as expected.
     
     """
     c = ColumnFromExpression()
-    c.column_name = 'c'
-    c.table = 'obs'
-    c.expression = 'a + b'
+    c.data.table = 'obs'
+    c.data.expression = 'a + b'
+    c.output.column_name = 'c'
     
     modelmanager.register(c)
-    modelmanager.remove_step(c.name)
+    modelmanager.remove_step(c.meta.name)
     assert('c' in orca.get_table('obs').columns)
 
 
@@ -174,17 +170,17 @@ def test_expression_with_standalone_columns(orca_session):
     
     """
     c = ColumnFromExpression()
-    c.column_name = 'c'
-    c.table = 'obs'
-    c.expression = 'a + b'
+    c.data.table = 'obs'
+    c.data.expression = 'a + b'
+    c.output.column_name = 'c'
     
     modelmanager.register(c)
-    modelmanager.remove_step(c.name)
+    modelmanager.remove_step(c.meta.name)
 
     d = ColumnFromExpression()
-    d.column_name = 'd'
-    d.table = 'obs'
-    d.expression = 'a + c'
+    d.data.table = 'obs'
+    d.data.expression = 'a + c'
+    d.output.column_name = 'd'
     
     d.run()
     assert('d' in orca.get_table('obs').columns)
diff --git a/tests/test_shared_core.py b/tests/test_shared_core.py
new file mode 100644
index 0000000..d0018b3
--- /dev/null
+++ b/tests/test_shared_core.py
@@ -0,0 +1,26 @@
+from __future__ import print_function
+
+import pytest
+
+from urbansim_templates.shared import CoreTemplateSettings
+
+
+def test_property_persistence():
+    """
+    Confirm CoreTemplateSettings properties persist through to_dict() and from_dict().
+    
+    """
+    obj = CoreTemplateSettings()
+    obj.name = 'name'
+    obj.tags = ['tag1', 'tag2']
+    obj.notes = 'notes'
+    obj.autorun = True
+    obj.template = 'CoolNewTemplate'
+    obj.template_version = '0.1.dev0'
+    
+    d = obj.to_dict()
+    print(d)
+    
+    obj2 = CoreTemplateSettings.from_dict(d)
+    assert(obj2.to_dict() == d)
+
diff --git a/tests/test_shared_output_column.py b/tests/test_shared_output_column.py
new file mode 100644
index 0000000..f2627f9
--- /dev/null
+++ b/tests/test_shared_output_column.py
@@ -0,0 +1,95 @@
+from __future__ import print_function
+
+import numpy as np
+import pandas as pd
+import pytest
+
+import orca
+
+from urbansim_templates.shared import OutputColumnSettings, register_column
+
+
+def test_property_persistence():
+    """
+    Confirm OutputColumnSettings properties persist through to_dict() and from_dict().
+    
+    """
+    obj = OutputColumnSettings()
+    obj.column_name = 'column'
+    obj.table = 'table'
+    obj.data_type = 'int32'
+    obj.missing_values = 5
+    obj.cache = True
+    obj.cache_scope = 'iteration'
+    
+    d = obj.to_dict()
+    print(d)
+    
+    obj2 = OutputColumnSettings.from_dict(d)
+    assert(obj2.to_dict() == d)
+
+
+# Tests for register_column()..
+
+@pytest.fixture
+def orca_session():
+    """
+    Set up a clean Orca session, with a data table.
+    
+    """
+    orca.clear_all()
+    
+    df = pd.DataFrame({'a': [0.1, 1.33, 2.4]}, index=[1,2,3])
+    orca.add_table('tab', df)
+
+
+def test_column_registration(orca_session):
+    """
+    Confirm column registration works.
+    
+    """
+    series = pd.Series([4,5,6], index=[1,2,3])
+    
+    def build_column():
+        return series
+    
+    settings = OutputColumnSettings(column_name='col', table='tab')
+    register_column(build_column, settings)
+    
+    assert(orca.get_table('tab').get_column('col').equals(series))
+
+
+def test_filling_missing_values(orca_session):
+    """
+    Confirm that filling missing values works.
+    
+    """
+    series1 = pd.Series([4.0, np.nan, 6.0], index=[1,2,3])
+    series2 = pd.Series([4.0, 5.0, 6.0], index=[1,2,3])
+    
+    def build_column():
+        return series1
+    
+    settings = OutputColumnSettings(column_name='col', table='tab', missing_values=5)
+    register_column(build_column, settings)
+    
+    assert(orca.get_table('tab').get_column('col').equals(series2))
+
+
+def test_casting_data_type(orca_session):
+    """
+    Confirm that filling missing values works.
+    
+    """
+    series1 = pd.Series([4.0, 5.0, 6.0], index=[1,2,3])
+    series2 = pd.Series([4, 5, 6], index=[1,2,3])
+    
+    def build_column():
+        return series1
+    
+    settings = OutputColumnSettings(column_name='col', table='tab', data_type='int')
+    register_column(build_column, settings)
+    
+    assert(orca.get_table('tab').get_column('col').equals(series2))
+
+
diff --git a/urbansim_templates/__init__.py b/urbansim_templates/__init__.py
index aba1d24..8157a0e 100644
--- a/urbansim_templates/__init__.py
+++ b/urbansim_templates/__init__.py
@@ -1 +1 @@
-version = __version__ = '0.2.dev5'
+version = __version__ = '0.2.dev6'
diff --git a/urbansim_templates/data/__init__.py b/urbansim_templates/data/__init__.py
index 90dc264..e9c7c54 100644
--- a/urbansim_templates/data/__init__.py
+++ b/urbansim_templates/data/__init__.py
@@ -1,3 +1,3 @@
-from .column_from_expression import ColumnFromExpression
+from .column_from_expression import ColumnFromExpression, ExpressionSettings
 from .load_table import LoadTable
 from .save_table import SaveTable
diff --git a/urbansim_templates/data/column_from_expression.py b/urbansim_templates/data/column_from_expression.py
index a7ce796..bf2ae34 100644
--- a/urbansim_templates/data/column_from_expression.py
+++ b/urbansim_templates/data/column_from_expression.py
@@ -1,35 +1,21 @@
-from __future__ import print_function
-
-import re
-
 import orca
 import pandas as pd
 
-from urbansim_templates import modelmanager, __version__
-from urbansim_templates.utils import get_df
+from urbansim_templates import modelmanager, shared, utils, __version__
+from urbansim_templates.shared import CoreTemplateSettings, OutputColumnSettings
 
 
-@modelmanager.template
-class ColumnFromExpression():
+class ExpressionSettings():
     """
-    Template to register a column of derived data with Orca, based on an expression. The 
-    column will be associated with an existing table. Values will be calculated lazily, 
-    only when the column is needed for a specific operation. 
-    
-    The expression will be passed to ``df.eval()`` and can refer to any columns in the 
-    same table. See the Pandas documentation for further details.
-    
-    All the parameters can also be set as properties after creating the template 
-    instance.
+    Stores custom parameters used by the 
+    :mod:`~urbansim_templates.data.ColumnFromExpression` template. Parameters can be
+    passed to the constructor or set as attributes.
     
     Parameters
     ----------
-    column_name : str, optional
-        Name of the Orca column to be registered. Required before running.
-    
     table : str, optional
-        Name of the Orca table the column will be associated with. Required before 
-        running.
+        Name of Orca table the expression will be evaluated on. Required before running
+        then template.
     
     expression : str, optional
         String describing operations on existing columns of the table, for example 
@@ -37,157 +23,128 @@ class ColumnFromExpression():
         including sqrt, abs, log, log1p, exp, and expm1 -- see Pandas ``df.eval()`` 
         documentation for further details.
     
-    data_type : str, optional
-        Python type or ``numpy.dtype`` to cast the column's values into.
-    
-    missing_values : str or numeric, optional
-        Value to use for rows that would otherwise be missing.
-    
-    cache : bool, default False
-        Whether to cache column values after they are calculated.
-    
-    cache_scope : 'step', 'iteration', or 'forever', default 'forever'
-        How long to cache column values for (ignored if ``cache`` is False).
-    
-    name : str, optional
-        Name of the template instance and associated model step. 
-    
-    tags : list of str, optional
-        Tags to associate with the template instance.
-    
-    autorun : bool, default True
-        Whether to run automatically when the template instance is registered with 
-        ModelManager.
-    
     """
-    def __init__(self, 
-            column_name = None, 
-            table = None, 
-            expression = None, 
-            data_type = None, 
-            missing_values = None, 
-            cache = False, 
-            cache_scope = 'forever', 
-            name = None,
-            tags = [], 
-            autorun = True):
-        
-        # Template-specific params
-        self.column_name = column_name
+    def __init__(self, table = None, expression = None):
         self.table = table
         self.expression = expression
-        self.data_type = data_type
-        self.missing_values = missing_values
-        self.cache = cache
-        self.cache_scope = cache_scope
-        
-        # Standard params
-        self.name = name
-        self.tags = tags
-        self.autorun = autorun
+    
+    @classmethod
+    def from_dict(cls, d):
+        return cls(table=d['table'], expression=d['expression'])
+
+    def to_dict(self):
+        return {'table': self.table, 'expression': self.expression}
+
+
+@modelmanager.template
+class ColumnFromExpression():
+    """
+    Template to register a column of derived data with Orca, based on an expression. 
+    Parameters may be passed to the constructor, but they are easier to set as
+    attributes. The expression can refer to any columns in the same table, and will be
+    evaluated using ``df.eval()``. Values will be calculated lazily, only when the column
+    is needed for a specific operation.
         
-        # Automatic params
-        self.template = self.__class__.__name__
-        self.template_version = __version__
+    Parameters
+    ----------
+    meta : :mod:`~urbansim_templates.shared.CoreTemplateSettings`, optional
+        Standard parameters. This template sets the default value of ``meta.autorun``
+        to True.
     
+    data : :mod:`~urbansim_templates.data.ExpressionSettings`, optional
+        Special parameters for this template.
+        
+    output : :mod:`~urbansim_templates.shared.OutputColumnSettings`, optional
+        Parameters for the column that will be generated. This template uses
+        ``data.table`` as the default value for ``output.table``.
+        
+    """
+    def __init__(self, meta=None, data=None, output=None):
+        
+        self.meta = CoreTemplateSettings(autorun=True) if meta is None else meta
+        self.meta.template = self.__class__.__name__
+        self.meta.template_version = __version__
+                
+        self.data = ExpressionSettings() if data is None else data
+        self.output = OutputColumnSettings() if output is None else output
     
+
     @classmethod
     def from_dict(cls, d):
         """
-        Create an object instance from a saved dictionary representation.
+        Create a class instance from a saved dictionary.
         
-        Parameters
-        ----------
-        d : dict
+        """
+        if 'meta' not in d:
+            return cls.from_dict_0_2_dev5(d)
         
-        Returns
-        -------
-        Table
+        return cls(
+            meta = CoreTemplateSettings.from_dict(d['meta']),
+            data = ExpressionSettings.from_dict(d['data']),
+            output = OutputColumnSettings.from_dict(d['output']))    
+    
+    
+    @classmethod
+    def from_dict_0_2_dev5(cls, d):
+        """
+        Converter to read saved data from 0.2.dev5 or earlier. Automatically invoked by
+        ``from_dict()`` as needed.
         
         """
-        obj = cls(
-            column_name = d['column_name'],
-            table = d['table'],
-            expression = d['expression'],
-            data_type = d['data_type'],
-            missing_values = d['missing_values'],
-            cache = d['cache'],
-            cache_scope = d['cache_scope'],
-            name = d['name'],
-            tags = d['tags'],
-            autorun = d['autorun']
-        )
-        return obj
+        return cls(
+            meta = CoreTemplateSettings(
+                name = d['name'],
+                tags = d['tags'],
+                autorun = d['autorun']),
+            data = ExpressionSettings(
+                table = d['table'],
+                expression = d['expression']),
+            output = OutputColumnSettings(
+                column_name = d['column_name'],
+                data_type = d['data_type'],
+                missing_values = d['missing_values'],
+                cache = d['cache'],
+                cache_scope = d['cache_scope']))
     
     
     def to_dict(self):
         """
         Create a dictionary representation of the object.
         
-        Returns
-        -------
-        dict
-        
         """
-        d = {
-            'template': self.template,
-            'template_version': self.template_version,
-            'name': self.name,
-            'tags': self.tags,
-            'autorun': self.autorun,
-            'column_name': self.column_name,
-            'table': self.table,
-            'expression': self.expression,
-            'data_type': self.data_type,
-            'missing_values': self.missing_values,
-            'cache': self.cache,
-            'cache_scope': self.cache_scope,
-        }
-        return d
+        return {
+            'meta': self.meta.to_dict(), 
+            'data': self.data.to_dict(),
+            'output': self.output.to_dict()}
     
     
     def run(self):
         """
-        Run the template, registering a column of derived data with Orca.
-        
-        Requires values to be set for ``column_name``, ``table``, and ``expression``.
-        
-        Returns
-        -------
-        None
+        Run the template, registering a column of derived data with Orca. Requires values
+        to be set for ``data.table``, ``data.expression``, and ``output.column_name``.
         
         """
-        if self.column_name is None:
-            raise ValueError("Please provide a column name")
-        
-        if self.table is None:
+        if self.data.table is None:
             raise ValueError("Please provide a table")
         
-        if self.expression is None:
+        if self.data.expression is None:
             raise ValueError("Please provide an expression")
         
-        # Some column names in the expression may not be part of the core DataFrame, so 
-        # we'll need to request them from Orca explicitly. This regex pulls out column 
-        # names into a list, by identifying tokens in the expression that begin with a 
-        # letter and contain any number of alphanumerics or underscores, but do not end 
-        # with an opening parenthesis. This will also pick up constants, like "pi", but  
-        # invalid column names will be ignored when we request them from get_df().
-        cols = re.findall('[a-zA-Z_][a-zA-Z0-9_]*(?!\()', self.expression)
+        if self.output.column_name is None:
+            raise ValueError("Please provide a column name")
+        
+        settings = self.output
         
-        @orca.column(table_name = self.table, 
-                     column_name = self.column_name, 
-                     cache = self.cache, 
-                     cache_scope = self.cache_scope)
-        def orca_column():
-            df = get_df(self.table, columns=cols)
-            series = df.eval(self.expression)
-            
-            if self.missing_values is not None:
-                series = series.fillna(self.missing_values)
-            
-            if self.data_type is not None:
-                series = series.astype(self.data_type)
-            
+        if settings.table is None:
+            settings.table = self.data.table
+
+        cols = utils.cols_in_expression(self.data.expression)
+        
+        def build_column():
+            df = utils.get_df(self.data.table, columns=cols)
+            series = df.eval(self.data.expression)
             return series
+
+        shared.register_column(build_column, settings)
         
     
\ No newline at end of file
diff --git a/urbansim_templates/data/load_table.py b/urbansim_templates/data/load_table.py
index 344ecf6..3aa6f55 100644
--- a/urbansim_templates/data/load_table.py
+++ b/urbansim_templates/data/load_table.py
@@ -16,13 +16,12 @@
 @modelmanager.template
 class LoadTable():
     """
-    Class for registering data tables from local CSV or HDF files.
+    Template for registering data tables from local CSV or HDF files. Parameters can be
+    passed to the constructor or set as attributes.
     
     An instance of this template class stores *instructions for loading a data table*, 
     packaged into an Orca step. Running the instructions registers the table with Orca. 
     
-    All the parameters can also be set as properties after creating the class instance.
-    
     Parameters
     ----------
     table : str, optional
diff --git a/urbansim_templates/data/save_table.py b/urbansim_templates/data/save_table.py
index c05813f..052f928 100644
--- a/urbansim_templates/data/save_table.py
+++ b/urbansim_templates/data/save_table.py
@@ -12,9 +12,8 @@
 @modelmanager.template
 class SaveTable():
     """
-    Class for saving Orca tables to local CSV or HDF5 files.
-    
-    All the parameters can also be set as properties after creating the class instance.
+    Template for saving Orca tables to local CSV or HDF5 files. Parameters can be passed
+    to the constructor or set as attributes.
     
     Parameters
     ----------
diff --git a/urbansim_templates/modelmanager.py b/urbansim_templates/modelmanager.py
index c1f4582..da064f2 100644
--- a/urbansim_templates/modelmanager.py
+++ b/urbansim_templates/modelmanager.py
@@ -97,12 +97,14 @@ def build_step(d):
     object
     
     """
+    template = d['meta']['template'] if 'meta' in d else d['template']
+    
     if 'supplemental_objects' in d:
         for i, item in enumerate(d['supplemental_objects']):
             content = load_supplemental_object(d['name'], **item)
             d['supplemental_objects'][i]['content'] = content
     
-    return _templates[d['template']].from_dict(d)
+    return _templates[template].from_dict(d)
     
 
 def load_supplemental_object(step_name, name, content_type, required=True):
@@ -151,25 +153,36 @@ def register(step, save_to_disk=True):
     None
     
     """
-    if step.name is None:
-        step.name = update_name(step.template, step.name)  # TO DO - test this
+    # Currently supporting both step.name and step.meta.name
+    if hasattr(step, 'meta'):
+        # TO DO: move the name updating to CoreTemplateSettings?
+        step.meta.name = update_name(step.meta.template, step.meta.name)
+        name = step.meta.name
+    
+    else:
+        step.name = update_name(step.template, step.name)
+        name = step.name
     
     if save_to_disk:
         save_step_to_disk(step)
     
-    print("Registering model step '{}'".format(step.name))
+    print("Registering model step '{}'".format(name))
     
-    _steps[step.name] = step
+    _steps[name] = step
     
     # Create a callable that runs the model step, and register it with orca
     def run_step():
         return step.run()
         
-    orca.add_step(step.name, run_step)
+    orca.add_step(name, run_step)
+    
+    if hasattr(step, 'meta'):
+        if step.meta.autorun:
+            orca.run([name])
     
-    if hasattr(step, 'autorun'):
+    elif hasattr(step, 'autorun'):
         if step.autorun:
-            orca.run([step.name]) 
+            orca.run([name]) 
         
     
 def list_steps():
@@ -181,9 +194,18 @@ def list_steps():
     list of dicts, ordered by name
     
     """
-    return [{'name': _steps[k].name,
-             'template': type(_steps[k]).__name__,
-             'tags': _steps[k].tags} for k in sorted(_steps.keys())]
+    steps = []
+    for k in sorted(_steps.keys()):
+        if hasattr(_steps[k], 'meta'):
+            steps += [{'name': _steps[k].meta.name,
+                       'template': _steps[k].meta.template,
+                       'tags': _steps[k].meta.tags,
+                       'notes': _steps[k].meta.notes}]
+        else:
+            steps += [{'name': _steps[k].name,
+                       'template': _steps[k].template,
+                       'tags': _steps[k].tags}]
+    return steps
     
 
 def save_step_to_disk(step):
@@ -192,11 +214,13 @@ def save_step_to_disk(step):
     'model-name.yaml' and will be saved to the initialization directory. 
     
     """
+    name = step.meta.name if hasattr(step, 'meta') else step.name
+
     if _disk_store is None:
         print("Please run 'modelmanager.initialize()' before registering new model steps")
         return
     
-    print("Saving '{}.yaml': {}".format(step.name, 
+    print("Saving '{}.yaml': {}".format(name, 
             os.path.join(os.getcwd(), _disk_store)))
     
     d = step.to_dict()
@@ -204,7 +228,7 @@ def save_step_to_disk(step):
     # Save supplemental objects
     if 'supplemental_objects' in d:
         for item in filter(None, d['supplemental_objects']):
-            save_supplemental_object(step.name, **item)
+            save_supplemental_object(name, **item)
             del item['content']
     
     # Save main yaml file
@@ -213,7 +237,7 @@ def save_step_to_disk(step):
     content = OrderedDict(headers)
     content.update({'saved_object': d})
     
-    yamlio.convert_to_yaml(content, os.path.join(_disk_store, step.name+'.yaml'))
+    yamlio.convert_to_yaml(content, os.path.join(_disk_store, name+'.yaml'))
     
 
 def save_supplemental_object(step_name, name, content, content_type, required=True):
diff --git a/urbansim_templates/shared/__init__.py b/urbansim_templates/shared/__init__.py
new file mode 100644
index 0000000..c2c00b1
--- /dev/null
+++ b/urbansim_templates/shared/__init__.py
@@ -0,0 +1,2 @@
+from .core import CoreTemplateSettings
+from .output_column import OutputColumnSettings, register_column
diff --git a/urbansim_templates/shared/core.py b/urbansim_templates/shared/core.py
new file mode 100644
index 0000000..e5ba71b
--- /dev/null
+++ b/urbansim_templates/shared/core.py
@@ -0,0 +1,95 @@
+from urbansim_templates import __version__
+
+
+class CoreTemplateSettings():
+    """
+    Stores standard parameters and logic used by all templates. Parameters can be passed 
+    to the constructor or set as attributes.
+    
+    Parameters
+    ----------
+    name : str, optional
+        Name of the configured template instance.
+    
+    tags : list of str, optional
+        Tags associated with the configured template instance.
+    
+    notes : str, optional
+        Notes associates with the configured template instance.
+    
+    autorun : bool, optional
+        Whether to run the configured template instance automatically when it's 
+        registered or loaded by ModelManager. The overall default is False, but the 
+        default can be overriden at the template level.
+    
+    template : str
+        Name of the template class associated with a configured instance.
+    
+    template_version : str
+        Version of the template class package.
+    
+    """
+    def __init__(self,
+            name = None,
+            tags = [],
+            notes = None,
+            autorun = False,
+            template = None,
+            template_version = None):
+        
+        self.name = name
+        self.tags = tags
+        self.notes = notes
+        self.autorun = autorun
+        self.template = template
+        self.template_version = template_version
+        
+        # automatic attributes
+        self.modelmanager_version = __version__
+    
+    
+    @classmethod
+    def from_dict(cls, d):
+        """
+        Create a class instance from a saved dictionary representation.
+        
+        Parameters
+        ----------
+        d : dict
+        
+        Returns
+        -------
+        obj : CoreTemplateSettings
+        
+        """
+        obj = cls(
+            name = d['name'],
+            tags = d['tags'],
+            notes = d['notes'],
+            autorun = d['autorun'],
+            template = d['template'],
+            template_version = d['template_version'],
+        )
+        return obj
+    
+    
+    def to_dict(self):
+        """
+        Create a dictionary representation of the object.
+        
+        Returns
+        -------
+        d : dict
+        
+        """
+        d = {
+            'name': self.name,
+            'tags': self.tags,
+            'notes': self.notes,
+            'autorun': self.autorun,
+            'template': self.template,
+            'template_version': self.template_version,
+            'modelmanager_version': self.modelmanager_version,
+        }
+        return d
+
diff --git a/urbansim_templates/shared/output_column.py b/urbansim_templates/shared/output_column.py
new file mode 100644
index 0000000..e66566b
--- /dev/null
+++ b/urbansim_templates/shared/output_column.py
@@ -0,0 +1,128 @@
+import orca
+
+from urbansim_templates import __version__
+
+
+class OutputColumnSettings():
+    """
+    Stores standard parameters used by templates that generate or modify columns. 
+    Parameters can be passed to the constructor or set as attributes.
+    
+    Parameters
+    ----------
+    column_name : str, optional
+        Name of the Orca column to be created or modified. Generally required before
+        running a configured template.
+    
+    table : str, optional
+        Name of Orca table the column will be associated with. Generally required before
+        running the configured template.
+    
+    data_type : str, optional
+        Python type or ``numpy.dtype`` to case the column's values to.
+    
+    missing_values : str or numeric, optional
+        Value to use for rows that would otherwise be missing.
+    
+    cache : bool, default False
+        Whether to cache column values after they are calculated
+    
+    cache_scope : 'step', 'iteration', or 'forever', default 'forever'
+        How long to cache column values for (ignored if ``cache`` is False).
+    
+    """
+    # TO DO: say something about Orca defaults and about core vs. computed columns.
+
+    def __init__(self,
+            column_name = None,
+            table = None,
+            data_type = None,
+            missing_values = None,
+            cache = False,
+            cache_scope = 'forever'):
+        
+        self.column_name = column_name
+        self.table = table
+        self.data_type = data_type
+        self.missing_values = missing_values
+        self.cache = cache
+        self.cache_scope = cache_scope
+        
+        # automatic attributes
+        self.modelmanager_version = __version__
+    
+    
+    @classmethod
+    def from_dict(cls, d):
+        """
+        Create a class instance from a saved dictionary representation.
+        
+        Parameters
+        ----------
+        d : dict
+        
+        Returns
+        -------
+        obj : OutputColumnSettings
+        
+        """
+        return cls(
+            column_name = d['column_name'],
+            table = d['table'],
+            data_type = d['data_type'],
+            missing_values = d['missing_values'],
+            cache = d['cache'],
+            cache_scope = d['cache_scope'])
+    
+    
+    def to_dict(self):
+        """
+        Create a dictionary representation of the object.
+        
+        Returns
+        -------
+        d : dict
+        
+        """
+        return {
+            'column_name': self.column_name,
+            'table': self.table,
+            'data_type': self.data_type,
+            'missing_values': self.missing_values,
+            'cache': self.cache,
+            'cache_scope': self.cache_scope,
+            'modelmanager_version': self.modelmanager_version}
+
+
+######################################
+######################################
+
+
+def register_column(build_column, settings):
+    """
+    Register a callable as an Orca column.
+    
+    Parameters
+    ----------
+    build_column : callable
+        Callable should return a ``pd.Series``. 
+    
+    settings : ColumnOutputSettings
+    
+    """
+    @orca.column(table_name = settings.table, 
+                 column_name = settings.column_name, 
+                 cache = settings.cache, 
+                 cache_scope = settings.cache_scope)
+
+    def orca_column():
+        series = build_column()
+        
+        if settings.missing_values is not None:
+            series = series.fillna(settings.missing_values)
+        
+        if settings.data_type is not None:
+            series = series.astype(settings.data_type)
+        
+        return series
+    
diff --git a/urbansim_templates/utils.py b/urbansim_templates/utils.py
index 73dc6d7..7879ffb 100644
--- a/urbansim_templates/utils.py
+++ b/urbansim_templates/utils.py
@@ -1,5 +1,6 @@
 from __future__ import print_function
 
+import re
 from datetime import datetime as dt
 
 import pandas as pd
@@ -346,6 +347,27 @@ def all_cols(table):
     return list(table.index.names) + list(table.columns)
     
 
+def cols_in_expression(expression):
+    """
+    Extract all possible column names from a ``df.eval()``-style expression. 
+    
+    This is achieved using regex to identify tokens in the expression that begin with a
+    letter and contain any number of alphanumerics or underscores, but do not end with an
+    opening parenthesis. This excludes function names, but would not exclude constants
+    (e.g. "pi"), which are semantically indistinguishable from column names.
+    
+    Parameters
+    ----------
+    expression : str
+    
+    Returns
+    -------
+    cols : list of str
+    
+    """
+    return re.findall('[a-zA-Z_][a-zA-Z0-9_]*(?!\()', expression)
+
+
 def trim_cols(df, columns=None):
     """
     Limit a DataFrame to columns that appear in a list of names. List may contain