diff --git a/test/accessibility.html b/test/accessibility.html
new file mode 100644
index 000000000..1fe191275
--- /dev/null
+++ b/test/accessibility.html
@@ -0,0 +1,330 @@
+<!doctype html>
+
+<html>
+
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0">
+
+  <script src="../../webcomponentsjs/webcomponents-lite.js"></script>
+  <script src="../../web-component-tester/browser.js"></script>
+  <script src="../../iron-test-helpers/mock-interactions.js"></script>
+
+  <link rel="import" href="helpers.html">
+  <link rel="import" href="../vaadin-grid.html">
+  <link rel="import" href="../vaadin-grid-column-group.html">
+</head>
+
+<body>
+  <test-fixture id="default">
+    <template>
+      <vaadin-grid>
+        <vaadin-grid-column>
+          <template class="header">Index</template>
+          <template>[[index]]</template>
+          <template class="footer">Index</template>
+        </vaadin-grid-column>
+        <vaadin-grid-column>
+          <template class="header">header</template>
+          <template>[[item]]</template>
+          <template class="footer">footer</template>
+        </vaadin-grid-column>
+      </vaadin-grid>
+    </template>
+  </test-fixture>
+
+  <test-fixture id="group">
+    <template>
+      <vaadin-grid>
+        <vaadin-grid-column-group>
+          <template class="header">Group header</template>
+          <template class="footer">Group footer</template>
+          <vaadin-grid-column>
+            <template class="header">Index</template>
+            <template>[[index]]</template>
+          </vaadin-grid-column>
+          <vaadin-grid-column>
+            <template class="header">header</template>
+            <template>[[item]]</template>
+          </vaadin-grid-column>
+        </vaadin-grid-column-group>
+      </vaadin-grid>
+    </template>
+  </test-fixture>
+
+  <test-fixture id="details">
+    <template>
+      <vaadin-grid>
+        <vaadin-grid-column>
+          <template class="header">Index</template>
+          <template>[[index]]</template>
+          <template class="footer">Index</template>
+        </vaadin-grid-column>
+        <vaadin-grid-column>
+          <template class="header">header</template>
+          <template>[[item]]</template>
+          <template class="footer">footer</template>
+        </vaadin-grid-column>
+        <template class="row-details">details</template>
+      </vaadin-grid>
+    </template>
+  </test-fixture>
+
+  <script>
+    describe('accessibility', () => {
+      let grid;
+
+      function initFixture(fixtureName) {
+        grid = fixture(fixtureName);
+        grid.items = ['foo', 'bar'];
+        flushGrid(grid);
+      }
+
+      function uniqueAttrValues(elements, attr) {
+        const unique = [], valuesSet = new Set();
+        Array.from(elements).forEach(el => valuesSet.add(el.getAttribute(attr)));
+        valuesSet.forEach(v => unique.push(v));
+        return unique;
+      }
+
+      describe('structural roles', () => {
+        beforeEach(() => initFixture('default'));
+
+        it('should have role grid on table', () => {
+          expect(grid.$.table.getAttribute('role')).to.equal('grid');
+        });
+
+        it('should have role rowgroup on row groups', () => {
+          expect(grid.$.header.getAttribute('role')).to.equal('rowgroup');
+          expect(grid.$.items.getAttribute('role')).to.equal('rowgroup');
+          expect(grid.$.footer.getAttribute('role')).to.equal('rowgroup');
+        });
+
+        it('should have role row on rows', () => {
+          expect(grid.$.header.children[0].getAttribute('role')).to.equal('row');
+          expect(grid.$.items.children[0].getAttribute('role')).to.equal('row');
+          expect(grid.$.items.children[1].getAttribute('role')).to.equal('row');
+          expect(grid.$.footer.children[0].getAttribute('role')).to.equal('row');
+        });
+
+        it('should have role columnheader on header cells', () => {
+          expect(grid.$.header.children[0].children[0].getAttribute('role')).to.equal('columnheader');
+          expect(grid.$.header.children[0].children[1].getAttribute('role')).to.equal('columnheader');
+        });
+
+        it('should have role gridcell on body cells', () => {
+          expect(grid.$.items.children[0].children[0].getAttribute('role')).to.equal('gridcell');
+          expect(grid.$.items.children[0].children[1].getAttribute('role')).to.equal('gridcell');
+        });
+      });
+
+      describe('size', () => {
+        beforeEach(() => initFixture('default'));
+
+        it('should have aria-rowcount on the table', () => {
+          // 2 item rows + header row + footer row = 4 in total
+          expect(grid.$.table.getAttribute('aria-rowcount')).to.equal('4');
+        });
+
+        it('should update aria-rowcount on after size change', () => {
+          grid.size = 10;
+
+          // 10 item rows + header row + footer row = 12 in total
+          expect(grid.$.table.getAttribute('aria-rowcount')).to.equal('12');
+        });
+      });
+
+      describe('column count', () => {
+        beforeEach(() => initFixture('details'));
+
+        it('should have aria-colcount on the table', () => {
+          expect(grid.$.table.getAttribute('aria-colcount')).to.equal('2');
+        });
+
+        it('should update aria-colcount when column is added', done => {
+          const template = document.createElement('template');
+          template.innerHTML = '[[item]]';
+          const column = document.createElement('vaadin-grid-column');
+          column.appendChild(template);
+          grid.appendChild(column);
+
+          setTimeout(() => {
+            expect(grid.$.table.getAttribute('aria-colcount')).to.equal('3');
+            done();
+          });
+        });
+      });
+
+      describe('row numbers', () => {
+        beforeEach(() => initFixture('group'));
+
+        function setANumberOfItems(grid, number) {
+          grid.items = Array.apply(null, new Array(number)).map((v, i) => `item ${i}`);
+          flushGrid(grid);
+        }
+
+        it('should have aria-rowindex on rows', () => {
+          Array.from(grid.$.table.querySelectorAll('tr')).forEach((row, index) => {
+            expect(row.getAttribute('aria-rowindex')).to.equal((index + 1).toString());
+          });
+        });
+
+        it('should update aria-rowindex on size change', () => {
+          setANumberOfItems(grid, 100);
+          expect(
+            Array.from(grid.$.items.children)
+              .slice(0, 5) // assuming at least five body rows are visible
+              .map(row => row.getAttribute('aria-rowindex'))
+          ).to.eql(['3', '4', '5', '6', '7']);
+          expect(grid.$.footer.children[0].getAttribute('aria-rowindex')).to.equal('103');
+        });
+
+        it('should update aria-rowindex on scroll', () => {
+          setANumberOfItems(grid, 1000);
+          // scroll to end
+          grid._accessIronListAPI(() => grid.scrollToIndex(1000));
+
+          const ariaRowindexValues = Array.from(grid.$.items.children)
+            .map(row => row.getAttribute('aria-rowindex'));
+          expect(ariaRowindexValues).to.include.members(['1000', '1001', '1002']);
+          expect(ariaRowindexValues).to.not.include.members(['3', '4', '1003']);
+        });
+      });
+
+      describe('selection', () => {
+        beforeEach(() => initFixture('default'));
+
+        it('should have aria-multiselectable on table', () => {
+          expect(grid.$.table.getAttribute('aria-multiselectable')).to.equal('true');
+        });
+
+        it('should have aria-selected defined on body rows', () => {
+          expect(uniqueAttrValues(
+            grid.$.items.querySelectorAll('tr'),
+            'aria-selected'
+          )).to.eql(['false']);
+        });
+
+        it('should have aria-selected defined on body cells', () => {
+          expect(uniqueAttrValues(
+            grid.$.items.querySelectorAll('td'),
+            'aria-selected'
+          )).to.eql(['false']);
+        });
+
+        it('should set aria-selected true for selected items', () => {
+          grid.selectedItems = grid.items.slice(1);
+
+          expect(grid.$.items.children[0].getAttribute('aria-selected')).to.equal('false');
+          expect(uniqueAttrValues(
+            grid.$.items.children[0].children,
+            'aria-selected'
+          )).to.eql(['false']);
+          expect(grid.$.items.children[1].getAttribute('aria-selected')).to.equal('true');
+          expect(uniqueAttrValues(
+            grid.$.items.children[1].children,
+            'aria-selected'
+          )).to.eql(['true']);
+        });
+
+        it('should set aria-selected false for deselected items', () => {
+          grid.selectedItems = grid.items.slice(1);
+          grid.selectedItems = [];
+
+          expect(grid.$.items.children[0].getAttribute('aria-selected')).to.equal('false');
+          expect(uniqueAttrValues(
+            grid.$.items.children[0].children,
+            'aria-selected'
+          )).to.eql(['false']);
+          expect(grid.$.items.children[1].getAttribute('aria-selected')).to.equal('false');
+          expect(uniqueAttrValues(
+            grid.$.items.children[1].children,
+            'aria-selected'
+          )).to.eql(['false']);
+        });
+      });
+
+      describe('column groups', () => {
+        beforeEach(() => initFixture('group'));
+
+        it('should have aria-colspan on group header cell', () => {
+          expect(grid.$.header.children[0].children[0].getAttribute('aria-colspan')).to.equal('2');
+        });
+      });
+
+      describe('row details', () => {
+        describe('not in use', () => {
+          beforeEach(() => initFixture('default'));
+
+          it('should not have aria-expanded on body cells', () => {
+            expect(uniqueAttrValues(
+              grid.$.items.querySelectorAll('td'),
+              'aria-expanded'
+            )).to.eql([null]);
+          });
+
+          it('should not have aria-controls on body cells', () => {
+            expect(uniqueAttrValues(
+              grid.$.items.querySelectorAll('td'),
+              'aria-controls'
+            )).to.eql([null]);
+          });
+        });
+
+        describe('in use', () => {
+          beforeEach(() => initFixture('details'));
+
+          it('should have aria-expanded false on body cells', () => {
+            expect(uniqueAttrValues(
+              grid.$.items.querySelectorAll('td'),
+              'aria-expanded'
+            )).to.eql(['false']);
+          });
+
+          it('should have aria-controls referencing detail cell id on body cells', () => {
+            Array.from(grid.$.items.children).forEach(row => {
+              const detailsCell = row.querySelector('td[part~="details-cell"]');
+
+              expect(detailsCell.id).to.be.ok;
+              expect(detailsCell.getAttribute('aria-controls')).to.equal(null);
+              expect(uniqueAttrValues(
+                row.querySelectorAll('td:not([part~="details-cell"])'),
+                'aria-controls'
+              )).to.eql([detailsCell.id]);
+            });
+          });
+
+          it('should set aria-expended true on cells after row expanded', () => {
+            grid.expandItem(grid.items[0]);
+
+            expect(uniqueAttrValues(
+              grid.$.items.children[0].children,
+              'aria-expanded'
+            )).to.eql(['true']);
+
+            expect(uniqueAttrValues(
+              grid.$.items.children[1].children,
+              'aria-expanded'
+            )).to.eql(['false']);
+          });
+
+          it('should set aria-expanded false on cells after row collapsed', () => {
+            grid.expandItem(grid.items[0]);
+            grid.collapseItem(grid.items[0]);
+
+            expect(uniqueAttrValues(
+              grid.$.items.children[0].children,
+              'aria-expanded'
+            )).to.eql(['false']);
+
+            expect(uniqueAttrValues(
+              grid.$.items.children[1].children,
+              'aria-expanded'
+            )).to.eql(['false']);
+          });
+        });
+      });
+    });
+  </script>
+</body>
+</html>
diff --git a/test/index.html b/test/index.html
index 4ff6d2109..0bddb5ef2 100644
--- a/test/index.html
+++ b/test/index.html
@@ -18,6 +18,7 @@
 <body>
   <script>
     WCT.loadSuites([
+      'accessibility.html',
       'app-localize-behavior.html',
       'array-data-provider.html',
       'basic.html',
diff --git a/test/keyboard-navigation.html b/test/keyboard-navigation.html
index 5026491a7..24184f2db 100644
--- a/test/keyboard-navigation.html
+++ b/test/keyboard-navigation.html
@@ -1616,144 +1616,6 @@
         });
       });
 
-      // TODO(platosha): reimplement these a11y features with native ARIA attributes
-      describe.skip('a11y', () => {
-        it('should move focus when focused cell is changed', () => {
-          const spy = sinon.spy();
-          footerTrap._primary.focus = spy;
-          footerTrap._secondary.focus = spy;
-
-          footerTrap.activeTarget = 'foobar';
-
-          expect(spy.callCount).to.equal(1);
-        });
-
-        it('should set announce target when virtual focus changes', () => {
-          tabToHeader();
-
-          expect(footerTrap.activeTarget).not.to.be.empty;
-        });
-
-        it('should announce row number on body when navigating with keys', () => {
-          const spy = sinon.spy();
-          grid.addEventListener('iron-announce', spy);
-
-          tabToHeader();
-          spy.reset();
-          tab();
-
-          expect(spy.callCount).to.equal(1);
-          expect(spy.args[0][0].detail.text).to.equal('Row 1 of 2');
-        });
-
-        it('should announce selection using template variable', () => {
-          const spy = sinon.spy();
-          grid.addEventListener('iron-announce', spy);
-
-          getRowCell(0, 0).instance.selected = true;
-
-          expect(grid.selectedItems).to.contain(grid.items[0]);
-          expect(spy.callCount).to.equal(1);
-          expect(spy.args[0][0].detail.text).to.equal('Selected Row 1 of 2');
-        });
-
-        it('should announce deselection using template variable', () => {
-          const spy = sinon.spy();
-          grid.addEventListener('iron-announce', spy);
-
-          grid.selectItem(grid.items[0]);
-          getRowCell(0, 0).instance.selected = false;
-
-          expect(spy.callCount).to.equal(1);
-          expect(spy.args[0][0].detail.text).to.equal('Deselected Row 1 of 2');
-        });
-
-        it('should announce focused cell when focused', done => {
-          tabToHeader();
-          tab();
-
-          const id = getRowCell(0, 0)._cellContent.id;
-          expect(id).to.match(/vaadin-grid-cell-content-\d+/);
-
-          footerTrap.async(() => {
-            expect(footerTrap._primary.getAttribute('aria-labelledby') +
-              footerTrap._secondary.getAttribute('aria-labelledby')).to.contain(id);
-            done();
-          });
-        });
-
-        it('should announce header cell when body cell is focused', done => {
-          tabToHeader();
-          tab();
-
-          const id = getFirstHeaderCell(0)._cellContent.id;
-          expect(id).to.match(/vaadin-grid-cell-content-\d+/);
-
-          footerTrap.async(() => {
-            expect(footerTrap._primary.getAttribute('aria-labelledby') +
-              footerTrap._secondary.getAttribute('aria-labelledby')).to.contain(id);
-            done();
-          });
-        });
-
-        it('should not refocus the trap while navigating', () => {
-          tabToHeader();
-          tab();
-
-          // Neither of these keystrokes should call trap focus(). Otherwise,
-          // if the trap focus is called, the focus could jump twice between
-          // the baits on a single keystroke, and, as a result of two jumps,
-          // the bait that was focused before the keystroke stays focused
-          // after. No focus move — no cell announce.
-          right();
-          left();
-          down();
-          up();
-          end();
-          home();
-          ctrlEnd();
-          ctrlHome();
-          pageDown();
-          pageUp();
-
-          expect(footerTrap.focus.callCount).to.equal(1);
-        });
-
-        it('should change activeTarget in the trap while navigating', () => {
-          tabToHeader();
-          tab();
-
-          let visitedTargets = [];
-          visitedTargets.push(footerTrap.activeTarget); right();
-          visitedTargets.push(footerTrap.activeTarget); left();
-          visitedTargets.push(footerTrap.activeTarget); down();
-          visitedTargets.push(footerTrap.activeTarget); up();
-          visitedTargets.push(footerTrap.activeTarget); end();
-          visitedTargets.push(footerTrap.activeTarget); home();
-          visitedTargets.push(footerTrap.activeTarget); ctrlEnd();
-          visitedTargets.push(footerTrap.activeTarget); ctrlHome();
-          visitedTargets.push(footerTrap.activeTarget); pageDown();
-          visitedTargets.push(footerTrap.activeTarget); pageUp();
-
-          // Extract unique values
-          visitedTargets = visitedTargets.reduce((acc, val) => {
-            if (acc.indexOf(val) === -1) {
-              acc.push(val);
-            }
-            return acc;
-          }, []);
-
-          expect(visitedTargets).to.have.a.lengthOf(5);
-        });
-
-        if (window.Polymer && Polymer.Settings.useNativeShadow) {
-          it('should have tabbable elements in the light DOM', () => {
-            expect(footerTrap.querySelector('.primary')).not.to.be.null;
-            expect(footerTrap.querySelector('.secondary')).not.to.be.null;
-          });
-        }
-      });
-
       describe('focus events on cell content', () => {
         let cell;
 
diff --git a/test/sorting.html b/test/sorting.html
index dbe9716bd..dfbd525fe 100644
--- a/test/sorting.html
+++ b/test/sorting.html
@@ -60,7 +60,7 @@
     describe('sorting', () => {
 
       describe('sorter', () => {
-        let sorter, title, button, indicators, orderIndicator, announcer;
+        let sorter, title, button, indicators, orderIndicator;
 
         beforeEach(() => {
 
@@ -69,7 +69,6 @@
           button = sorter.querySelector('button');
           indicators = sorter.shadowRoot.querySelector('[part="indicators"]');
           orderIndicator = sorter.shadowRoot.querySelector('[part="order"]');
-          announcer = sorter.shadowRoot.querySelector('#announcer');
         });
 
         function clickSorter(sorter) {
@@ -118,112 +117,11 @@
           expect(sorter.getAttribute('direction')).to.equal('desc');
         });
 
-        it('should have aria-hidden for indicator', () => {
-          expect(indicators.getAttribute('aria-hidden')).to.equal('true');
-        });
-
         it('should prevent default on click', () => {
           const clickEvent = clickSorter(sorter);
 
           expect(clickEvent.defaultPrevented).to.be.true;
         });
-
-        describe('announcer', () => {
-          it('should reflect direction', () => {
-            expect(announcer.textContent).to.have.string('Unsorted');
-            expect(announcer.textContent).to.not.have.string('Sorted');
-
-            sorter.direction = 'asc';
-            expect(announcer.textContent).to.have.string('Sorted');
-            expect(announcer.textContent).to.not.have.string('Unsorted');
-            expect(announcer.textContent).to.have.string('ascending');
-            expect(announcer.textContent).to.not.have.string('descending');
-
-            sorter.direction = 'desc';
-            expect(announcer.textContent).to.have.string('Sorted');
-            expect(announcer.textContent).to.not.have.string('Unsorted');
-            expect(announcer.textContent).to.have.string('descending');
-            expect(announcer.textContent).to.not.have.string('ascending');
-          });
-
-          it('should reflect order', () => {
-            sorter.direction = 'asc';
-
-            expect(announcer.textContent).to.not.have.string('Order');
-
-            sorter._order = 0;
-            expect(announcer.textContent).to.have.string('Order 1');
-
-            sorter._order = 4;
-            expect(announcer.textContent).to.have.string('Order 5');
-          });
-
-          it('should announce direction change', () => {
-            const spy = sinon.spy();
-            sorter.addEventListener('iron-announce', spy);
-
-            sorter.direction = 'asc';
-
-            sorter._debouncerDirectionAnnounce.flush();
-
-            expect(spy.callCount).to.eql(1);
-          });
-
-          it('should announce order change', () => {
-            const spy = sinon.spy();
-            sorter.addEventListener('iron-announce', spy);
-
-            sorter._order = 0;
-
-            sorter._debouncerDirectionAnnounce.flush();
-
-            expect(spy.callCount).to.eql(1);
-          });
-
-          it('should debounce direction and order changes', () => {
-            const spy = sinon.spy();
-            sorter.addEventListener('iron-announce', spy);
-
-            sorter.direction = 'asc';
-            sorter._order = 0;
-
-            sorter._debouncerDirectionAnnounce.flush();
-
-            expect(spy.callCount).to.eql(1);
-            expect(spy.args[0][0].detail.text).to.eql('Sorted ascending, Order 1.');
-          });
-        });
-      });
-
-      describe('sorter in cell content', () => {
-        let cellContent, sorter, announcer;
-
-        beforeEach(() => {
-
-          cellContent = fixture('sorter-in-cell-content');
-          sorter = cellContent.querySelector('vaadin-grid-sorter');
-          announcer = sorter.shadowRoot.querySelector('#announcer');
-        });
-
-        it('should have aria-hidden state on announcer by default', () => {
-          expect(announcer.getAttribute('aria-hidden')).to.equal('true');
-        });
-
-        it('should not have aria-hidden state on announcer after cell content receives focus', () => {
-          cellContent.dispatchEvent(new CustomEvent('cell-focusin'));
-
-          expect(announcer.getAttribute('aria-hidden')).to.equal('false');
-        });
-
-        it('should have aria-hidden state on announcer after cell content looses focus', done => {
-          cellContent.dispatchEvent(new CustomEvent('cell-focusin'));
-          cellContent.dispatchEvent(new CustomEvent('cell-focusout'));
-
-          setTimeout(() => {
-            expect(announcer.getAttribute('aria-hidden')).to.equal('true');
-            done();
-          }, 1);
-        });
       });
 
       describe('grid', () => {
@@ -489,6 +387,25 @@
           });
         });
 
+        describe('accessibility', () => {
+          function getSorterCell(sorter) {
+            return sorter.parentNode.assignedSlot.parentNode;
+          }
+
+          it('should set aria-sort on cells', () => {
+            expect(getSorterCell(sorterFirst).getAttribute('aria-sort')).to.equal('ascending');
+            expect(getSorterCell(sorterLast).getAttribute('aria-sort')).to.equal('descending');
+          });
+
+          it('should update aria-sort on sorter change', () => {
+            sorterFirst.direction = 'desc';
+            sorterLast.direction = null;
+
+            expect(getSorterCell(sorterFirst).getAttribute('aria-sort')).to.equal('descending');
+            expect(getSorterCell(sorterLast).getAttribute('aria-sort')).to.equal('none');
+          });
+        });
+
       });
 
     });
diff --git a/vaadin-grid-a11y-mixin.html b/vaadin-grid-a11y-mixin.html
new file mode 100644
index 000000000..6c7672793
--- /dev/null
+++ b/vaadin-grid-a11y-mixin.html
@@ -0,0 +1,110 @@
+<!--
+@license
+Copyright (c) 2017 Vaadin Ltd.
+This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
+-->
+
+<script>
+  window.Vaadin = window.Vaadin || {};
+  Vaadin.Grid = Vaadin.Grid || {};
+
+  /**
+   * @polymerMixin
+   */
+  Vaadin.Grid.A11yMixin = superClass => class A11yMixin extends superClass {
+    static get observers() {
+      return [
+        '_a11yUpdateGridSize(size, _columnTree, _columnTree.*)'
+      ];
+    }
+
+    _a11yGetHeaderRowCount(_columnTree) {
+      return _columnTree.filter(level => level.some(col => col.headerTemplate)).length;
+    }
+
+    _a11yGetFooterRowCount(_columnTree) {
+      return _columnTree.filter(level => level.some(col => col.headerTemplate)).length;
+    }
+
+    _a11yUpdateGridSize(size, _columnTree) {
+      if (size === undefined || _columnTree === undefined) return;
+
+      const bodyColumns = _columnTree[_columnTree.length - 1];
+      this.$.table.setAttribute(
+        'aria-rowcount',
+        size + this._a11yGetHeaderRowCount(_columnTree) + this._a11yGetFooterRowCount(_columnTree)
+      );
+      this.$.table.setAttribute('aria-colcount', bodyColumns && bodyColumns.length || 0);
+
+      this._a11yUpdateHeaderRows();
+      this._a11yUpdateFooterRows();
+    }
+
+    _a11yUpdateHeaderRows() {
+      Array.from(this.$.header.children).forEach((headerRow, index) =>
+        headerRow.setAttribute('aria-rowindex', index + 1)
+      );
+    }
+
+    _a11yUpdateFooterRows() {
+      Array.from(this.$.footer.children).forEach((footerRow, index) =>
+        footerRow.setAttribute(
+          'aria-rowindex',
+          this._a11yGetHeaderRowCount(this._columnTree) + this.size + index + 1
+        )
+      );
+    }
+
+    _a11yUpdateRowRowindex(row, index) {
+      row.setAttribute('aria-rowindex', index + this._a11yGetHeaderRowCount(this._columnTree) + 1);
+    }
+
+    _a11yUpdateRowSelected(row, selected) {
+      // Jaws reads selection only for rows, NVDA only for cells
+      row.setAttribute('aria-selected', Boolean(selected));
+      Array.from(row.children).forEach(cell =>
+        cell.setAttribute('aria-selected', Boolean(selected))
+      );
+    }
+
+    _a11yUpdateRowExpanded(row, expanded) {
+      Array.from(row.children).forEach(cell => {
+        if (typeof expanded === 'boolean') {
+          cell.setAttribute('aria-expanded', expanded);
+        } else {
+          if (cell.hasAttribute('aria-expanded')) {
+            cell.removeAttribute('aria-expanded');
+          }
+        }
+      });
+    }
+
+    _a11ySetRowDetailsCell(row, detailsCell) {
+      Array.from(row.children).forEach(cell => {
+        if (cell !== detailsCell) {
+          cell.setAttribute('aria-controls', detailsCell.id);
+        }
+      });
+    }
+
+    _a11yUpdateCellColspan(cell, colspan) {
+      cell.setAttribute('aria-colspan', Number(colspan));
+    }
+
+    _a11yUpdateSorters() {
+      Array.from(this.querySelectorAll('vaadin-grid-sorter')).forEach(sorter => {
+        let cellContent = sorter.parentNode;
+        while (cellContent && cellContent.localName !== 'vaadin-grid-cell-content') {
+          cellContent = cellContent.parentNode;
+        }
+        if (cellContent) {
+          const cell = cellContent.assignedSlot.parentNode;
+          cell.setAttribute('aria-sort', {
+            'asc': 'ascending',
+            'desc': 'descending'
+          }[String(sorter.direction)] || 'none');
+        }
+      });
+    }
+  };
+</script>
diff --git a/vaadin-grid-column-group.html b/vaadin-grid-column-group.html
index 061aa0510..c3df8c740 100644
--- a/vaadin-grid-column-group.html
+++ b/vaadin-grid-column-group.html
@@ -232,9 +232,11 @@
         _colSpanChanged(colSpan, headerCell, footerCell) {
           if (headerCell) {
             headerCell.setAttribute('colspan', colSpan);
+            this._grid && this._grid._a11yUpdateCellColspan(headerCell, colSpan);
           }
           if (footerCell) {
             footerCell.setAttribute('colspan', colSpan);
+            this._grid && this._grid._a11yUpdateCellColspan(footerCell, colSpan);
           }
         }
 
diff --git a/vaadin-grid-column-reordering-mixin.html b/vaadin-grid-column-reordering-mixin.html
index a7afc5354..f4edf54be 100644
--- a/vaadin-grid-column-reordering-mixin.html
+++ b/vaadin-grid-column-reordering-mixin.html
@@ -202,15 +202,7 @@
     _updateGhost(cell) {
       const ghost = this._reorderGhost;
 
-      const sorter = cell._content.querySelector('vaadin-grid-sorter');
-      if (sorter) {
-        // Hide sorter announcer text
-        sorter.$.announcer.hidden = true;
-      }
       ghost.textContent = cell._content.innerText;
-      if (sorter) {
-        sorter.$.announcer.hidden = false;
-      }
       const style = window.getComputedStyle(cell);
       ['boxSizing', 'display', 'width', 'height', 'background', 'alignItems', 'padding', 'border', 'flex-direction', 'overflow']
         .forEach(propertyName => ghost.style[propertyName] = style[propertyName]);
diff --git a/vaadin-grid-selection-mixin.html b/vaadin-grid-selection-mixin.html
index 3c4cc25dc..e86a35235 100644
--- a/vaadin-grid-selection-mixin.html
+++ b/vaadin-grid-selection-mixin.html
@@ -32,29 +32,6 @@
       ];
     }
 
-    ready() {
-      super.ready();
-      this.addEventListener('template-instance-changed', this._templateInstanceChangedSelection.bind(this));
-    }
-
-    _templateInstanceChangedSelection(e) {
-      if (e.detail.prop === 'selected') {
-        const item = e.detail.inst.item;
-        (this._isSelected(item) ? this.deselectItem : this.selectItem).call(this, item);
-
-        this.dispatchEvent(new CustomEvent('iron-announce', {
-          bubbles: true,
-          composed: true,
-          detail: {
-            text: (this._isSelected(item) ? 'Selected' : 'Deselected') + ' Row ' + (e.detail.inst.index + 1) + ' of ' + this.size
-          }
-        }));
-
-        // stop this internal event from propagating outside.
-        e.stopPropagation();
-      }
-    }
-
     _isSelected(item) {
       return this.selectedItems && this.selectedItems.indexOf(item) > -1;
     }
@@ -117,13 +94,7 @@
     _selectedItemsChanged(e) {
       if (this.$.items.children.length && (e.path === 'selectedItems' || e.path === 'selectedItems.splices')) {
         Array.from(this.$.items.children).forEach(row => {
-          const selected = this._isSelected(row._item);
-          this._toggleAttribute('selected', selected, row);
-          Array.from(row.children).forEach(cell => {
-            if (cell._instance) {
-              cell._instance.selected = selected;
-            }
-          });
+          this._toggleRowSelected(row, this._isSelected(row._item));
         });
       }
     }
diff --git a/vaadin-grid-sort-mixin.html b/vaadin-grid-sort-mixin.html
index bac90547a..fdc440a36 100644
--- a/vaadin-grid-sort-mixin.html
+++ b/vaadin-grid-sort-mixin.html
@@ -90,6 +90,8 @@
         this.clearCache();
       }
 
+      this._a11yUpdateSorters();
+
       this._previousSorters = this._mapSorters();
     }
 
diff --git a/vaadin-grid-sorter.html b/vaadin-grid-sorter.html
index 686efd43c..fb55a359e 100644
--- a/vaadin-grid-sorter.html
+++ b/vaadin-grid-sorter.html
@@ -81,22 +81,12 @@
       :host([direction=desc]) [part="indicators"]::before {
         content: "\e902";
       }
-
-      #announcer {
-        position: absolute;
-        z-index: -1;
-        clip: rect(0, 0, 0, 0);
-        text-transform: none;
-      }
     </style>
 
     <div part="content">
       <slot></slot>
     </div>
-    <div id="announcer" aria-hidden="true">
-      <div>[[_getAriaLabel(direction, _order)]]</div>
-    </div>
-    <div part="indicators" aria-hidden="true">
+    <div part="indicators">
       <div part="order">[[_getDisplayOrder(_order)]]</div>
     </div>
 
@@ -164,28 +154,9 @@
               value: null
             },
 
-            _cellHasFocus: {
-              type: Boolean,
-              value: false
-            },
-
             _isConnected: {
               type: Boolean,
               value: false
-            },
-
-            _boundOnCellContentFocusin: {
-              type: Function,
-              value: function() {
-                return this._onCellContentFocusin.bind(this);
-              }
-            },
-
-            _boundOnCellContentFocusout: {
-              type: Function,
-              value: function() {
-                return this._onCellContentFocusout.bind(this);
-              }
             }
           };
         }
@@ -193,8 +164,7 @@
         static get observers() {
           return [
             '_pathOrDirectionChanged(path, direction, _isConnected)',
-            '_directionOrOrderChanged(direction, _order)',
-            '_cellHasFocusChanged(_cellHasFocus)'
+            '_directionOrOrderChanged(direction, _order)'
           ];
         }
 
@@ -206,43 +176,11 @@
         connectedCallback() {
           super.connectedCallback();
           this._isConnected = true;
-          this._cellContent = this._getClosestCellContent();
-          if (this._cellContent) {
-            this._cellContent.addEventListener('cell-focusin', this._boundOnCellContentFocusin);
-            this._cellContent.addEventListener('cell-focusout', this._boundOnCellContentFocusout);
-          }
         }
 
         disconnectedCallback() {
           super.disconnectedCallback();
           this._isConnected = false;
-          if (this._cellContent) {
-            this._cellContent.removeEventListener('cell-focusin', this._boundOnCellContentFocusin);
-            this._cellContent.removeEventListener('cell-focusout', this._boundOnCellContentFocusout);
-            this._cellContent = undefined;
-          }
-        }
-
-        _getClosestCellContent() {
-          var el = this;
-          while (el = Polymer.dom(el).parentNode) {
-            if (el.localName === 'vaadin-grid' || el === document.body) {
-              // not found
-              return null;
-            }
-            if (el.localName === 'vaadin-grid-cell-content') {
-              // found
-              return el;
-            }
-          }
-        }
-
-        _onCellContentFocusin() {
-          this._cellHasFocus = true;
-        }
-
-        _onCellContentFocusout() {
-          this._cellHasFocus = false;
         }
 
         _pathOrDirectionChanged(path, direction, isConnected) {
@@ -276,32 +214,11 @@
           }
         }
 
-        _getAriaLabel(direction, order) {
-          if (direction) {
-            var label = 'Sorted ';
-            label += direction === 'asc' ? 'ascending' : 'descending';
-            label += order === null ? '. ' : (', Order ' + (order + 1) + '.');
-            return label;
-          } else {
-            return 'Unsorted.';
-          }
-        }
-
         _directionOrOrderChanged(direction, order) {
           if (direction === undefined || order === undefined) {
             return;
           }
 
-          this._debouncerDirectionAnnounce = Polymer.Debouncer.debounce(this._debouncerDirectionAnnounce,
-              Polymer.Async.timeOut.after(1),
-              () => this.dispatchEvent(new CustomEvent('iron-announce', {
-                bubbles: true,
-                composed: true,
-                detail: {
-                  text: this._getAriaLabel(direction, order)
-                }
-              })));
-
           // Safari has an issue with repainting shadow root element styles when a host attribute changes.
           // Need this workaround (toggle any inline css property on and off) until the issue gets fixed.
           var isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
@@ -312,21 +229,6 @@
             });
           }
         }
-
-        _cellHasFocusChanged(cellHasFocus) {
-          // Let us hide the a11y announces when the cell content parent
-          // of the sorter does not have virtual focus. This is needed to prevent
-          // the sorter announcement on every body cell of the sortable column.
-          if (cellHasFocus) {
-            this.$.announcer.setAttribute('aria-hidden', 'false');
-          } else {
-            // Wait before hiding the label to prevent readers like NVDA from reacting
-            // to changes for the unfocused cell.
-            this._debouncerAriaHidden = Polymer.Debouncer.debounce(this._debouncerAriaHidden,
-                Polymer.Async.timeOut.after(1),
-                () => this.$.announcer.setAttribute('aria-hidden', 'true'));
-          }
-        }
       }
 
       customElements.define(GridSorterElement.is, GridSorterElement);
diff --git a/vaadin-grid.html b/vaadin-grid.html
index e9f1c443e..18601529d 100644
--- a/vaadin-grid.html
+++ b/vaadin-grid.html
@@ -17,6 +17,7 @@
 <link rel="import" href="vaadin-grid-sort-mixin.html">
 <link rel="import" href="vaadin-grid-row-details-mixin.html">
 <link rel="import" href="vaadin-grid-keyboard-navigation-mixin.html">
+<link rel="import" href="vaadin-grid-a11y-mixin.html">
 <link rel="import" href="vaadin-grid-filter-mixin.html">
 <link rel="import" href="vaadin-grid-column-reordering-mixin.html">
 <link rel="import" href="vaadin-grid-column-resizing-mixin.html">
@@ -29,7 +30,7 @@
     <style include="vaadin-grid-styles"></style>
 
     <div id="scroller" no-scrollbars$="[[!_scrollbarWidth]]" safari$="[[_safari]]" ios$="[[_ios]]" loading$=[[_loading]] edge$="[[_edge]]">
-      <table id="table" role="application grid">
+      <table id="table" role="grid" aria-multiselectable="true">
         <caption id="fixedsizer" class="sizer" part="row"></caption>
         <thead id="header" role="rowgroup"></thead>
         <tbody id="items" role="rowgroup"></tbody>
@@ -196,10 +197,11 @@
       Vaadin.Grid.SortMixin(
       Vaadin.Grid.RowDetailsMixin(
       Vaadin.Grid.KeyboardNavigationMixin(
+      Vaadin.Grid.A11yMixin(
       Vaadin.Grid.FilterMixin(
       Vaadin.Grid.ColumnReorderingMixin(
       Vaadin.Grid.ColumnResizingMixin(
-      Vaadin.Grid.ScrollerElement)))))))))))))) {
+      Vaadin.Grid.ScrollerElement))))))))))))))) {
 
       static get is() {
         return 'vaadin-grid';
@@ -207,7 +209,7 @@
 
       static get observers() {
         return [
-          '_columnTreeChanged(_columnTree, _columnTree.*)',
+          '_columnTreeChanged(_columnTree, _columnTree.*)'
         ];
       }
 
@@ -286,12 +288,12 @@
         const slotName = 'vaadin-grid-cell-content-' + contentId;
 
         const cellContent = document.createElement('vaadin-grid-cell-content');
-
         cellContent.setAttribute('slot', slotName);
+
         const cell = document.createElement(tagName);
         cell.id = slotName.replace('-content-', '-');
         cell.setAttribute('tabindex', '-1');
-        cell.setAttribute('role', tagName === 'td' ? 'gridcell' : 'columnheader gridcell');
+        cell.setAttribute('role', tagName === 'td' ? 'gridcell' : 'columnheader');
 
         const slot = document.createElement('slot');
         slot.setAttribute('name', slotName);
@@ -351,17 +353,13 @@
               }
               this._configureDetailsCell(detailsCell);
               row.appendChild(detailsCell);
+              this._a11ySetRowDetailsCell(row, detailsCell);
               detailsCell._vacant = false;
             }
 
             if (column.notifyPath && !noNotify) {
               column.notifyPath('_cells.*', column._cells);
             }
-
-            const descriptionCell = column._headerCell || column._footerCell;
-            if (descriptionCell) {
-              cell.setAttribute('aria-labelledby', `${descriptionCell.id} ${cell.id}`);
-            }
           } else {
             // Header & footer
             const tagName = section === 'header' ? 'th' : 'td';
@@ -410,6 +408,7 @@
           }
         });
         this._toggleAttribute('odd', index % 2, row);
+        this._a11yUpdateRowRowindex(row, index);
         this._getItem(index, row);
       }
 
@@ -446,12 +445,14 @@
         this._frozenCellsChanged();
         this._updateLastColumn();
         this._resetKeyboardNavigation();
+        this._a11yUpdateHeaderRows();
+        this._a11yUpdateFooterRows();
       }
 
       _updateItem(row, item) {
         // row.style.minHeight = item ? '' : this.$.scroller._physicalAverage + 'px';
         row._item = item;
-        Array.from(row.children).forEach((cell) => {
+        Array.from(row.children).forEach(cell => {
           if (cell._instance) {
             if (cell._instance.item === item) {
               // Force data system to pick up subproperty changes
@@ -459,18 +460,36 @@
             }
             cell._instance.item = item;
             cell._instance.index = row.index;
-            cell._instance.__expanded__ = this._isExpanded(item);
-            cell._instance.expanded = this._isExpanded(item);
-            cell._instance.__selected__ = this._isSelected(item);
-            cell._instance.selected = this._isSelected(item);
           }
         });
-        this._toggleAttribute('selected', this._isSelected(item), row);
+        this._toggleRowSelected(row, this._isSelected(item));
+        this._toggleRowExpanded(row, this._rowDetailsTemplate && this._isExpanded(item));
         if (this._rowDetailsTemplate) {
           this._toggleDetailsCell(row, item);
         }
       }
 
+      _toggleRowExpanded(row, expanded) {
+        Array.from(row.children).forEach(cell => {
+          if (cell._instance) {
+            cell._instance.__expanded__ = expanded;
+            cell._instance.expanded = expanded;
+          }
+        });
+        this._a11yUpdateRowExpanded(row, expanded);
+      }
+
+      _toggleRowSelected(row, selected) {
+        Array.from(row.children).forEach(cell => {
+          if (cell._instance) {
+            cell._instance.__selected__ = selected;
+            cell._instance.selected = selected;
+          }
+        });
+        this._toggleAttribute('selected', selected, row);
+        this._a11yUpdateRowSelected(row, selected);
+      }
+
       _resizeHandler() {
         this._updateDetailsCellHeights();
         this._accessIronListAPI(super._resizeHandler, true);
