diff --git a/lib/elements/dom-bind.html b/lib/elements/dom-bind.html
index 8cd4487f8d..71486d026a 100644
--- a/lib/elements/dom-bind.html
+++ b/lib/elements/dom-bind.html
@@ -85,7 +85,7 @@
             observer.observe(this, {childList: true});
             return;
           }
-          this.root = this._stampBoundTemplate(template);
+          this.root = this._stampTemplate(template);
           this.$ = this.root.$;
           this.__children = [];
           for (let n=this.root.firstChild; n; n=n.nextSibling) {
diff --git a/lib/mixins/element-mixin.html b/lib/mixins/element-mixin.html
index b0b402cc16..29ee127f4e 100644
--- a/lib/mixins/element-mixin.html
+++ b/lib/mixins/element-mixin.html
@@ -622,7 +622,7 @@
       ready() {
         if (this._template) {
           hostStack.beginHosting(this);
-          this.root = this._stampBoundTemplate(this._template);
+          this.root = this._stampTemplate(this._template);
           hostStack.endHosting(this);
           this.$ = this.root.$;
         }
diff --git a/lib/mixins/property-accessors.html b/lib/mixins/property-accessors.html
index e045d2ef15..b15568e4c8 100644
--- a/lib/mixins/property-accessors.html
+++ b/lib/mixins/property-accessors.html
@@ -79,7 +79,10 @@
    * the standard `static get observedAttributes()`, implement `_propertiesChanged`
    * on the class, and then call `MyClass.createPropertiesForAttributes()` once
    * on the class to generate property accessors for each observed attribute
-   * prior to instancing.  Any `observedAttributes` will automatically be
+   * prior to instancing.  Last, call `this._flushProperties()` once to enable
+   * the accessors.
+   *
+   * Any `observedAttributes` will automatically be
    * deserialized via `attributeChangedCallback` and set to the associated
    * property using `dash-case`-to-`camelCase` convention.
    *
@@ -137,6 +140,7 @@
         this.__dataOld = null;
         if (this.__dataProto) {
           this._initializeProtoProperties(this.__dataProto);
+          this.__dataProto = null;
         }
         // Capture instance properties; these will be set into accessors
         // during first flush. Don't set them here, since we want
@@ -168,6 +172,22 @@
         }
       }
 
+      /**
+       * Called at ready time with bag of instance properties that overwrote
+       * accessors when the element upgraded.
+       *
+       * The default implementation sets these properties back into the
+       * setter at ready time.  This method is provided as an override
+       * point for customizing or providing more efficient initialization.
+       *
+       * @param {Object} props Bag of property values that were overwritten
+       *   when creating property accessors.
+       * @protected
+       */
+      _initializeInstanceProperties(props) {
+        Object.assign(this, props);
+      }
+
       /**
        * Ensures the element has the given attribute. If it does not,
        * assigns the given value to the attribute.
@@ -444,7 +464,7 @@
        * @protected
        */
       _invalidateProperties() {
-        if (!this.__dataInvalid) {
+        if (!this.__dataInvalid && this.__dataInitialized) {
           this.__dataInvalid = true;
           microtask.run(() => {
             if (this.__dataInvalid) {
@@ -460,17 +480,20 @@
        * pending changes (and old values recorded when pending changes were
        * set), and resets the pending set of changes.
        *
+       * Note that this method must be called once to enable the property
+       * accessors system.  For elements, generally `connectedCallback`
+       * is a normal spot to do so.
+       *
        * @protected
        */
       _flushProperties() {
         if (!this.__dataInitialized) {
           this.ready()
         } else if (this.__dataPending) {
-          let oldProps = this.__dataOld;
           let changedProps = this.__dataPending;
           this.__dataPending = null;
           this.__dataCounter++;
-          this._propertiesChanged(this.__data, changedProps, oldProps);
+          this._propertiesChanged(this.__data, changedProps, this.__dataOld);
           this.__dataCounter--;
         }
       }
@@ -493,7 +516,8 @@
         // Update instance properties that shadowed proto accessors; these take
         // priority over any defaults set in constructor or attributeChangedCallback
         if (this.__dataInstanceProps) {
-          Object.assign(this, this.__dataInstanceProps);
+          this._initializeInstanceProperties(this.__dataInstanceProps);
+          this.__dataInstanceProps = null;
         }
         this.__dataInitialized = true;
         // Run normal flush
diff --git a/lib/mixins/property-effects.html b/lib/mixins/property-effects.html
index 822cef13ca..435e558d4a 100644
--- a/lib/mixins/property-effects.html
+++ b/lib/mixins/property-effects.html
@@ -292,20 +292,6 @@
     dispatchNotifyEvent(inst, info.eventName, value, path);
   }
 
-  /**
-   * Adds a 2-way binding notification event listener to the node specified
-   *
-   * @param {Object} node Child element to add listener to
-   * @param {Object} inst Host element instance to handle notification event
-   * @param {Object} info Listener metadata stored via addAnnotatedListener
-   * @private
-   */
-  function addNotifyListener(node, inst, info) {
-    node.addEventListener(info.event, function(e) {
-      handleNotification(e, inst, info.target, info.source, info.negate);
-    });
-  }
-
   /**
    * Handler function for 2-way notification events. Receives context
    * information captured in the `addNotifyListener` closure from the
@@ -448,51 +434,70 @@
   // -- bindings ----------------------------------------------
 
   /**
-   * Adds "binding" property effects for the template annotation
-   * ("note" for short) and node index specified.  These may either be normal
-   * "binding" effects (property/path bindings) or "method binding"
-   * effects, aka inline computing functions, depending on the type of binding
-   * detailed in the note.
+   * Adds binding metadata to the current `nodeInfo`, and binding effects
+   * for all part dependencies to `templateInfo`.
    *
-   * @param {Object} model Prototype or instance
-   * @param {Object} note Annotation note returned from Annotator
-   * @param {number} index Index into `nodeList` that the binding applies to
-   * @param {Object=} dynamicFns Map indicating whether method names should
-   *   be included as a dependency to the effect.
+   * @param {Function} constructor Class that `_parseTemplate` is currently
+   *   running on
+   * @param {Object} templateInfo Template metadata for current template
+   * @param {Object} nodeInfo Node metadata for current template node
+   * @param {string} kind Binding kind, either 'property', 'attribute', or 'text'
+   * @param {string} target Target property name
+   * @param {Array<Object>} parts Array of binding part metadata
+   * @param {string} literal Literal text surrounding binding parts (specified
+   *   only for 'property' bindings, since these must be initialized as part
+   *   of boot-up)
    * @private
    */
   function addBinding(constructor, templateInfo, nodeInfo, kind, target, parts, literal) {
     // Create binding metadata and add to nodeInfo
     nodeInfo.bindings = nodeInfo.bindings || [];
     let binding = { kind, target, parts, literal, isCompound: (parts.length !== 1) };
-    let index = templateInfo.nodeInfoList.length;
     nodeInfo.bindings.push(binding);
-    // Add 2-way binding listener metadata to templateInfo
+    // Add listener info to binding metadata
     if (shouldAddListener(binding)) {
-      addAnnotatedListener(templateInfo, index, binding);
+      let {event, negate} = binding.parts[0];
+      binding.listenerEvent = event || (CaseMap.camelToDashCase(target) + '-changed');
+      binding.listenerNegate = negate;
     }
     // Add "propagate" property effects to templateInfo
+    let index = templateInfo.nodeInfoList.length;
     for (let i=0; i<binding.parts.length; i++) {
       let part = binding.parts[i];
-      if (!part.literal) {
-        if (binding.kind === 'attribute' && binding.target[0] === '-') {
-          console.warn('Cannot set attribute ' + binding.target +
-            ' because "-" is not a valid attribute starting character');
-        } else {
-          let dependencies = part.dependencies;
-          let info = { index, binding, part, evaluator: constructor };
-          part.compoundIndex = i;
-          for (let j=0; j<dependencies.length; j++) {
-            let trigger = dependencies[j];
-            if (typeof trigger == 'string') {
-              trigger = parseArg(trigger);
-              trigger.wildcard = true;
-            }
-            constructor._addTemplatePropertyEffect(templateInfo, trigger.rootProperty, {
-              fn: runBindingEffect,
-              info, trigger
-            });
+      part.compoundIndex = i;
+      addEffectForBindingPart(constructor, templateInfo, binding, part, index);
+    }
+  }
+
+  /**
+   * Adds property effects to the given `templateInfo` for the given binding
+   * part.
+   *
+   * @param {Function} constructor Class that `_parseTemplate` is currently
+   *   running on
+   * @param {Object} templateInfo Template metadata for current template
+   * @param {Object} binding Binding metadata
+   * @param {Object} part Binding part metadata
+   * @param {Number} index Index into `nodeInfoList` for this node
+   */
+  function addEffectForBindingPart(constructor, templateInfo, binding, part, index) {
+    if (!part.literal) {
+      if (binding.kind === 'attribute' && binding.target[0] === '-') {
+        console.warn('Cannot set attribute ' + binding.target +
+          ' because "-" is not a valid attribute starting character');
+      } else {
+        let dependencies = part.dependencies;
+        let info = { index, binding, part, evaluator: constructor };
+        for (let j=0; j<dependencies.length; j++) {
+          let trigger = dependencies[j];
+          if (typeof trigger == 'string') {
+            trigger = parseArg(trigger);
+            trigger.wildcard = true;
           }
+          constructor._addTemplatePropertyEffect(templateInfo, trigger.rootProperty, {
+            fn: runBindingEffect,
+            info, trigger
+          });
         }
       }
     }
@@ -501,6 +506,12 @@
   /**
    * Implements the "binding" (property/path binding) effect.
    *
+   * Note that binding syntax is overridable via `_parseBindings` and
+   * `_evaluateBindings`.  This method will call `_evaluateBinding` for any
+   * non-literal parts returned from `_parseBindings`.  However,
+   * there is no support for _path_ bindings via custom binding parts,
+   * as this is specific to Polymer's path binding syntax.
+   *
    * @param {Element} inst The instance the effect will be run on
    * @param {string} path Name of property
    * @param {*} value Current value of property
@@ -611,23 +622,6 @@
            binding.parts[0].mode === '{';
   }
 
-  /**
-   * Sets up a prototypical `__notifyListeners` metadata array to be used at
-   * instance time to add event listeners for 2-way bindings.
-   *
-   * @param {Object} model Prototype (instances not currently supported)
-   * @param {number} index Index into `nodeList` that the event should be added to
-   * @param {Object} binding Binding metadata
-   * @private
-   */
-  function addAnnotatedListener(templateInfo, index, binding) {
-    let target = binding.target;
-    let {source, negate} = binding.parts[0];
-    let event = binding.parts[0].event || (CaseMap.camelToDashCase(target) + '-changed');
-    let notifyListeners = templateInfo.notifyListeners || (templateInfo.notifyListeners = []);
-    notifyListeners.push({ index, source, target, event, negate });
-  }
-
   /**
    * Setup compound binding storage structures, notify listeners, and dataHost
    * references onto the bound nodeList.
@@ -637,7 +631,7 @@
    * @private
    */
   function setupBindings(inst, templateInfo) {
-    // Setup compound storage && dataHost
+    // Setup compound storage, dataHost, and notify listeners
     let {nodeList, nodeInfoList} = templateInfo;
     if (nodeInfoList.length) {
       for (let i=0; i < nodeInfoList.length; i++) {
@@ -645,21 +639,66 @@
         let node = nodeList[i];
         let bindings = info.bindings;
         if (bindings) {
-          setupCompoundBinding(node, bindings);
+          for (let i=0; i<bindings.length; i++) {
+            let binding = bindings[i];
+            setupCompoundStorage(node, binding);
+            addNotifyListener(node, inst, binding);
+          }
         }
+        addNotifyListener
         node.__dataHost = inst;
       }
     }
-    // Setup 2-way binding event listeners
-    let listeners = templateInfo.notifyListeners;
-    if (listeners) {
-      for (let i=0, l=listeners.length, info; (i<l) && (info=listeners[i]); i++) {
-        let node = nodeList[info.index];
-        addNotifyListener(node, inst, info);
+  }
+
+  /**
+   * Initializes `__dataCompoundStorage` local storage on a bound node with
+   * initial literal data for compound bindings, and sets the joined
+   * literal parts to the bound property.
+   *
+   * When changes to compound parts occur, they are first set into the compound
+   * storage array for that property, and then the array is joined to result in
+   * the final value set to the property/attribute.
+   *
+   * @param {Node} node Bound node to initialize
+   * @param {Object} bindings Binding metadata
+   * @private
+   */
+  function setupCompoundStorage(node, binding) {
+    if (binding.isCompound) {
+      // Create compound storage map
+      let storage = node.__dataCompoundStorage ||
+        (node.__dataCompoundStorage = {});
+      let parts = binding.parts;
+      // Copy literals from parts into storage for this binding
+      let literals = new Array(parts.length);
+      for (let j=0; j<parts.length; j++) {
+        literals[j] = parts[j].literal;
+      }
+      let target = binding.target;
+      storage[target] = literals;
+      // Configure properties with their literal parts
+      if (binding.literal && binding.kind == 'property') {
+        node[target] = binding.literal;
       }
     }
   }
 
+  /**
+   * Adds a 2-way binding notification event listener to the node specified
+   *
+   * @param {Object} node Child element to add listener to
+   * @param {Object} inst Host element instance to handle notification event
+   * @param {Object} info Listener metadata stored via addAnnotatedListener
+   * @private
+   */
+  function addNotifyListener(node, inst, binding) {
+    let part = binding.parts[0];
+    node.addEventListener(binding.listenerEvent, function(e) {
+      handleNotification(e, inst, binding.target, part.source, part.negate);
+    });
+  }
+
   // -- for method-based effects (complexObserver & computed) --------------
 
   /**
@@ -917,42 +956,6 @@
     return values;
   }
 
-  /**
-   * Initializes `__dataCompoundStorage` local storage on a bound node with
-   * initial literal data for compound bindings, and sets the joined
-   * literal parts to the bound property.
-   *
-   * When changes to compound parts occur, they are first set into the compound
-   * storage array for that property, and then the array is joined to result in
-   * the final value set to the property/attribute.
-   *
-   * @param {Node} node Bound node to initialize
-   * @param {Object} bindings Binding metadata
-   * @private
-   */
-  function setupCompoundBinding(node, bindings) {
-    for (let i=0; i<bindings.length; i++) {
-      let binding = bindings[i];
-      if (binding.isCompound) {
-        // Create compound storage map
-        let storage = node.__dataCompoundStorage ||
-          (node.__dataCompoundStorage = {});
-        let parts = binding.parts;
-        // Copy literals from parts into storage for this binding
-        let literals = new Array(parts.length);
-        for (let j=0; j<parts.length; j++) {
-          literals[j] = parts[j].literal;
-        }
-        let target = binding.target;
-        storage[target] = literals;
-        // Configure properties with their literal parts
-        if (binding.literal && binding.kind == 'property') {
-          node[target] = binding.literal;
-        }
-      }
-    }
-  }
-
   // data api
 
   /**
@@ -1029,9 +1032,6 @@
    * but are designed to be called on element prototypes such that the work to
    * set up accessors and effect metadata are done once per element class.
    *
-   * Additionally, it provides "bound template" stamping facilities:
-   * - `_stampBoundTemplate`
-   *
    * Note that this mixin overrides several `PropertyAccessors` methods, in
    * many cases to maintain guarantees provided by the Polymer 1.x features;
    * notably it changes property accessors to be synchronous by default
@@ -1091,6 +1091,23 @@
         this.__dataOld = {};
       }
 
+      /**
+       * Overrides `Polymer.PropertyAccessors` implementation to avoid setting
+       * `_setProperty`'s `shouldNotify: true`.
+       *
+       * @override
+       */
+      _initializeInstanceProperties(props) {
+        let readOnly = this.__readOnly;
+        for (let prop in props) {
+          if (!readOnly || !readOnly[prop]) {
+            this.__dataPending = this.__dataPending || {};
+            this.__dataOld = this.__dataOld || {};
+            this.__data[prop] = this.__dataPending[prop] = props[prop];
+          }
+        }
+      }
+
       // Prototype setup ----------------------------------------
 
       /**
@@ -1986,31 +2003,31 @@
        * prototypically bound template and/or one or more templates to stamp
        * bound to the instance.
        *
+       * Note that a template may only be stamped by one element; stamping
+       * the same template by multiple element types is not currently supported.
+       *
        * @param {HTMLTemplateElement} template Template containing binding
        *   bindings
        * @param {DocumentFragment=} dom Stamped DOM for this template to be
        *   bound to the instance (leave undefined for prototypical template
        *   binding)
-       * @return {Object} Template metadata object
+       * @return {Object} Instanced template metadata object
        * @protected
        */
-      _bindTemplate(template, dom) {
+      _bindTemplate(template) {
         let templateInfo = this.constructor._parseTemplate(template);
-        let templateWasPrebound = this.__templateInfo == templateInfo;
-        if (!templateWasPrebound) {
+        if (!templateInfo.hasCreatedAccessors) {
           // Create accessors for any template effects
           for (let prop in templateInfo.propertyEffects) {
             this._createPropertyAccessor(prop);
           }
+          templateInfo.hasCreatedAccessors = true;
         }
-        if (dom) {
-          templateInfo = dom.templateInfo = Object.create(templateInfo);
-          templateInfo.nodeList = dom.nodeList;
-          if (!templateWasPrebound && this.__templateInfo) {
-            templateInfo.nextTemplateInfo = this.__templateInfo;
-            this.__templateInfo.previousTemplateInfo = templateInfo;
-            templateInfo.childNodes = Array.from(dom.childNodes);
-          }
+        // Create instance of template metadata and link into list of templates
+        templateInfo = Object.create(templateInfo);
+        if (this.hasOwnProperty('__templateInfo')) {
+          templateInfo.nextTemplateInfo = this.__templateInfo;
+          this.__templateInfo.previousTemplateInfo = templateInfo;
         }
         return this.__templateInfo = templateInfo;
       }
@@ -2053,11 +2070,15 @@
        * @return {DocumentFragment} Cloned template content
        * @protected
        */
-      _stampBoundTemplate(template) {
+      _stampTemplate(template) {
         let dom = super._stampTemplate(template);
         // Link template info & create accessors
         let templateInfo = this._bindTemplate(template, dom);
-        // Setup compound storage, 2-way listeners, and dataHost
+        // Add template-instance-specific data to instanced templateInfo
+        templateInfo.nodeList = dom.nodeList;
+        templateInfo.childNodes = Array.from(dom.childNodes);
+        dom.templateInfo = templateInfo;
+        // Setup compound storage, 2-way listeners, and dataHost for bindings
         setupBindings(this, templateInfo);
         // Flush properties into template nodes if already booted
         if (this.__dataInitialized) {
@@ -2069,13 +2090,13 @@
 
       /**
        * Removes and unbinds the nodes previously contained in the provided
-       * DocumentFragment returned from `_stampBoundTemplate`.
+       * DocumentFragment returned from `_stampTemplate`.
        *
        * @param {DocumentFragment} dom DocumentFragment previously returned
-       *   from `_stampBoundTemplate` associated with the nodes to be removed
+       *   from `_stampTemplate` associated with the nodes to be removed
        * @protected
        */
-      _unstampBoundTemplate(dom) {
+      _unstampTemplate(dom) {
         // Unlink template info
         let templateInfo = dom.templateInfo;
         if (templateInfo.previousTemplateInfo) {
@@ -2105,7 +2126,7 @@
        * @override
        * @param {Node} node Node to parse
        * @param {Object} templateInfo Template metadata for current template
-       * @param {Object} nodeInfo Node metadata for current template.
+       * @param {Object} nodeInfo Node metadata for current template node
        * @return {boolean} `true` if the visited node added node-specific
        *   metadata to `nodeInfo`
        * @protected
@@ -2137,7 +2158,7 @@
        * @override
        * @param {Node} node Node to parse
        * @param {Object} templateInfo Template metadata for current template
-       * @param {Object} nodeInfo Node metadata for current template.
+       * @param {Object} nodeInfo Node metadata for current template node
        * @return {boolean} `true` if the visited node added node-specific
        *   metadata to `nodeInfo`
        * @protected
@@ -2188,7 +2209,7 @@
        * @override
        * @param {Node} node Node to parse
        * @param {Object} templateInfo Template metadata for current template
-       * @param {Object} nodeInfo Node metadata for current template.
+       * @param {Object} nodeInfo Node metadata for current template node
        * @return {boolean} `true` if the visited node added node-specific
        *   metadata to `nodeInfo`
        * @protected
diff --git a/lib/utils/templatize.html b/lib/utils/templatize.html
index b1e9f2d864..383889faa7 100644
--- a/lib/utils/templatize.html
+++ b/lib/utils/templatize.html
@@ -44,7 +44,7 @@
       constructor(props) {
         super();
         this._configureProperties(props);
-        this.root = this._stampBoundTemplate(this.__dataHost);
+        this.root = this._stampTemplate(this.__dataHost);
         // Save list of stamped children
         let children = this.children = [];
         for (let n = this.root.firstChild; n; n=n.nextSibling) {
diff --git a/test/unit/property-accessors.html b/test/unit/property-accessors.html
index 8947a509f1..9fb9a4f61c 100644
--- a/test/unit/property-accessors.html
+++ b/test/unit/property-accessors.html
@@ -28,6 +28,9 @@
         super();
         this._propertiesChanged = sinon.spy();
       }
+      connectedCallback() {
+        this._flushProperties();
+      }
     }
     XFoo.createPropertiesForAttributes();
     window.XFoo = XFoo;