diff --git a/field_permission_example/css/field_permission_example.css b/field_permission_example/css/field_permission_example.css
new file mode 100644
index 0000000..59cda31
--- /dev/null
+++ b/field_permission_example/css/field_permission_example.css
@@ -0,0 +1,22 @@
+/**
+ * @file
+ * CSS for Field Example.
+ */
+.stickynote {
+background:#fefabc;
+padding:0.8em;
+font-family:cursive;
+font-size:1.1em;
+color: #000;
+width:15em;
+
+-moz-transform: rotate(2deg);
+-webkit-transform: rotate(2deg);
+-o-transform: rotate(2deg);
+-ms-transform: rotate(2deg);
+transform: rotate(2deg);
+
+box-shadow: 0px 4px 6px #333;
+-moz-box-shadow: 0px 4px 6px #333;
+-webkit-box-shadow: 0px 4px 6px #333;
+}
diff --git a/field_permission_example/field_permission_example.info.yml b/field_permission_example/field_permission_example.info.yml
new file mode 100644
index 0000000..d59c28f
--- /dev/null
+++ b/field_permission_example/field_permission_example.info.yml
@@ -0,0 +1,8 @@
+name: Field Permission Example
+type: module
+description: An example module that creates a field and puts access control over it.
+package: Example modules
+version: 8.x-1.x
+core: 8.x
+dependencies:
+  - examples
diff --git a/field_permission_example/field_permission_example.libraries.yml b/field_permission_example/field_permission_example.libraries.yml
new file mode 100644
index 0000000..ca63cb8
--- /dev/null
+++ b/field_permission_example/field_permission_example.libraries.yml
@@ -0,0 +1,5 @@
+fieldnote_sticky:
+  version: 1.x
+  css:
+    theme:
+      css/field_permission_example.css: {}
diff --git a/field_permission_example/field_permission_example.links.menu.yml b/field_permission_example/field_permission_example.links.menu.yml
new file mode 100644
index 0000000..ce9a56b
--- /dev/null
+++ b/field_permission_example/field_permission_example.links.menu.yml
@@ -0,0 +1,3 @@
+field_permission_example.description:
+  title: Field Permission Example
+  route_name: field_permission_example.description
diff --git a/field_permission_example/field_permission_example.module b/field_permission_example/field_permission_example.module
new file mode 100644
index 0000000..3d14e0f
--- /dev/null
+++ b/field_permission_example/field_permission_example.module
@@ -0,0 +1,166 @@
+<?php
+
+/**
+ * @file
+ * An example field using the Field Types API.
+ */
+ 
+/**
+ * @defgroup field_permission_example Example: Field Permissions
+ * @ingroup examples
+ * @{
+ * Example using permissions on a Field API field.
+ *
+ * This example is a relatively simple text field you can attach to
+ * any fieldable entity.
+ *
+ * In this module we demonstrate how to limit access to a field.
+ * Drupal's Field API gives you two operations to permit or restrict:
+ * view and edit. So you can then decide who gets to see fields,
+ * who can edit them, and who can manage them.
+ *
+ * Our field is called field_permission_example_fieldnote. It has a
+ * simple default widget of a text area, and a default formatter
+ * that applies a CSS style to make it look like a sticky note.
+ *
+ * In addition to demonstrating how to set up permissions-based
+ * access to a field, this module also demonstrates the absolute
+ * minimum required to implement a field, since it doesn't have
+ * any field settings.
+ *
+ * If you wish to use this code as skeleton code for a field without
+ * permissions, you can simply remove field_permission_exampe_permission()
+ * and field_permission_field_access(). Also field_permission_example_menu()
+ * and _field_permission_example_page() are vestigial to the Examples
+ * project.
+ *
+ * How does it work?
+ *
+ * You can install this module and go to path /examples/field_permission_example
+ * for an introduction on how to use this field.
+ *
+ * OK, how does the code work?
+ *
+ * As with any permission system, we create a MODULE_NAME.permissions.yml
+ * file order to define a few permissions. In our case, users will want
+ * to either view or edit fieldnote fields. And, similar to the way
+ * node permissions work, we'll also include a context of either
+ * their own content or any content. So that gives us 4 permissions
+ * which administrators can assign to various roles. See
+ * field_permission_example.permissions.yml for the list.
+ *
+ * With our permissions defined in the YAML file, we can now
+ * handle requests for access. Those come in through
+ * hook_field_access(), which we've implemented as
+ * field_permission_example_field_acces(). This function determines
+ * whether the user has the ability to view or edit the field
+ * in question by calling user_access(). We also give special edit
+ * access to users with the 'bypass node access' and
+ * 'administer content types' permissions, defined by the node module.
+ *
+ * One tricky part is that our field won't always be attached to
+ * nodes. It could be attached to any type of entity. This means
+ * that there's no general way to figure out if the user 'owns'
+ * the entity or not. Since this is a simple example, we'll just
+ * check for 'any' access to unknown entity types. We'll also
+ * limit our known entity types to node and user, since those
+ * are easy to demonstrate.
+ *
+ * In a real application, we'd have use-case specific permissions
+ * which might be more complex than these. Or perhaps simpler.
+ *
+ * You can see a more complex field implementation in
+ * field_example.module.
+ *
+ * @see field_example
+ * @see field_example.module
+ * @see field_types
+ * @see field
+ */
+ 
+//use statements to support hook_entity_field_access
+use Drupal\Core\Field\FieldDefinitionInterface;
+use Drupal\Core\Session\AccountInterface;
+use Drupal\Core\Field\FieldItemListInterface;
+use Drupal\Core\Access\AccessResult;
+
+//Interfaces used by entities to declare "ownership"
+use Drupal\user\EntityOwnerInterface;
+use Drupal\user\UserInterface;
+ 
+/**
+ * Implements hook_entity_field_access().
+ *
+ * We want to make sure that fields aren't being seen or edited
+ * by those who shouldn't.
+ *
+ * The tricky thing here is that a field can be attached to any type
+ * of entity, so it's not always trivial to figure out whether
+ * $account 'owns' the entity. Since most entities that can be "owned"
+ * implement EntityOwnerInterface, we can test for this very simply.
+ */
+
+/**
+ * Implementation of hook_entity_field_access
+ */ 
+function field_permission_example_entity_field_access($operation, FieldDefinitionInterface $field_definition, AccountInterface $account, FieldItemListInterface $items = NULL) {
+  //Find out what field we're looking at.  If it isn't
+  //our sticky note widget, tell Drupal we don't care about its access
+  if ($field_definition->getType() != 'field_permission_example_fieldnote') {
+    return AccessResult::neutral();    
+  }
+  
+  // First we'll check if the user has the 'superuser'
+  // permissions that node provides. This way administrators
+  // will be able to administer the content types.
+  if ($account->hasPermission('bypass node access')) {
+    drupal_set_message(t('User can bypass node access.'));
+    return AccessResult::allowed();
+  }
+  if ($account->hasPermission('administer content types', $account)) {
+    drupal_set_message(t('User can administer content types.'));
+    return AccessResult::allowed();
+  }
+  if ($account->hasPermission('administer the fieldnote field', $account)) {
+    drupal_set_message(t('User can administer this field.'));
+    return AccessResult::allowed();
+  }
+
+  //for anyone else, it depends on the desired operation
+  if ($operation == 'view' and $account->hasPermission('view any fieldnote')) {
+    drupal_set_message(t('User can view any field note.'));
+    return AccessResult::allowed();
+  }
+  
+  if ($operation == 'edit' and $account->hasPermission('edit any fieldnote')) {
+    drupal_set_message(t('User can edit any field note.'));
+    return AccessResult::allowed();
+  }
+  
+  //At this point, we need to know if the user "owns" the entity we're attached to.
+  //If it's a user, we'll use the account name to test.  Otherwise rely on the entity implementing the 
+  //the EntityOwnerInterface.  Anything else can't be owned, and we'll refuse access.
+  if ($items) {
+    $entity = $items->getEntity();
+    if ((($entity instanceof EntityOwnerInterface) and
+         $entity->getOwner()->getAccountName() == $account->getAccountName()) or
+        (($entity instanceof UserInterface) and
+         $entity->name->value == $account->getAccountName())
+        ) {
+      if ($operation == 'view' and $account->hasPermission('view own fieldnote')) {
+        drupal_set_message(t('User can view their own field note.'));
+        return AccessResult::allowed();
+      }
+      if ($operation == 'edit' and $account->hasPermission('edit own fieldnote')) {
+        drupal_set_message(t('User can edit their own field note.'));
+        return AccessResult::allowed();
+      }
+    }
+  }
+  //anything else on this field is forbidden
+  return AccessResult::forbidden();
+}
+
+/**
+ * @} End of "defgroup field_permission_example".
+ */
diff --git a/field_permission_example/field_permission_example.permissions.yml b/field_permission_example/field_permission_example.permissions.yml
new file mode 100644
index 0000000..c70eb2b
--- /dev/null
+++ b/field_permission_example/field_permission_example.permissions.yml
@@ -0,0 +1,11 @@
+# Permissions for the field_permission_example module
+'view own fieldnote':
+  title: View own fieldnote
+'edit own fieldnote':
+  title: Edit own fieldnote
+'view any fieldnote':
+  title: View any fieldnote
+'edit any fieldnote':
+  title: Edit any fieldnote
+'administer the fieldnote field':
+  title: Administer settings for the fieldnote field.
diff --git a/field_permission_example/field_permission_example.routing.yml b/field_permission_example/field_permission_example.routing.yml
new file mode 100644
index 0000000..aebf40c
--- /dev/null
+++ b/field_permission_example/field_permission_example.routing.yml
@@ -0,0 +1,7 @@
+field_permission_example.description:
+  path: 'examples/field_permission_example'
+  defaults:
+    _title: 'Field Permission Example'
+    _controller: '\Drupal\field_permission_example\Controller\FieldPermissionExampleController::description'
+  requirements:
+    _access: 'TRUE'
diff --git a/field_permission_example/src/Controller/FieldPermissionExampleController.php b/field_permission_example/src/Controller/FieldPermissionExampleController.php
new file mode 100644
index 0000000..095e96a
--- /dev/null
+++ b/field_permission_example/src/Controller/FieldPermissionExampleController.php
@@ -0,0 +1,34 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\field_permission_example\Controller\FieldPermissionExampleController.
+ */
+
+namespace Drupal\field_permission_example\Controller;
+
+use Drupal\Core\Controller\ControllerBase;
+use Drupal\Core\Url;
+
+/**
+ * Controller routines for block example routes.
+ */
+class FieldPermissionExampleController extends ControllerBase {
+
+  /**
+   * A simple controller method to explain what this example is about.
+   */
+  public function description() {
+    // Make a link from a route to the permissions admin page.
+    $url = Url::fromRoute('user.admin_permissions');
+    $permissions_admin_link = $this->l($this->t('the permissions admin page'), $url);
+
+    // Put the link into the content.
+    $build = array(
+      '#markup' => $this->t('<p>The Field Permission Example provides a simple "fieldnote" widget that can be attached to any fieldable entity.  View and Edit access to the field is controlled via the permissions for this module, which you can assign to roles and users, which you can enable at the !permissions_admin_link.</p>', ['!permissions_admin_link' => $permissions_admin_link]),
+    );
+
+    return $build;
+  }
+
+}
diff --git a/field_permission_example/src/Plugin/Field/FieldFormatter/SimpleTextFormatter.php b/field_permission_example/src/Plugin/Field/FieldFormatter/SimpleTextFormatter.php
new file mode 100644
index 0000000..ac9229c
--- /dev/null
+++ b/field_permission_example/src/Plugin/Field/FieldFormatter/SimpleTextFormatter.php
@@ -0,0 +1,54 @@
+<?php
+
+/**
+ * @file
+ * Contains Drupal\field_permission_example\Plugin\Field\FieldFormatter\SimpleTextFormatter.
+ */
+
+namespace Drupal\field_permission_example\Plugin\Field\FieldFormatter;
+
+use Drupal\Core\Field\FormatterBase;
+use Drupal\Core\Field\FieldItemListInterface;
+
+/**
+ * Plugin implementation of the 'field_permission_example_simple_text' formatter.
+ *
+ * @FieldFormatter(
+ *   id = "field_permission_example_simple_formatter",
+ *   module = "field_permission_example",
+ *   label = @Translation("Simple text-based formatter"),
+ *   field_types = {
+ *     "field_permission_example_fieldnote"
+ *   }
+ * )
+ */
+class SimpleTextFormatter extends FormatterBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function viewElements(FieldItemListInterface $items, $langcode) {
+   $elements = array();
+
+    foreach ($items as $delta => $item) {
+      $elements[$delta] = array(
+        // We wrap the fieldnote content up in a div tag.
+        '#type' => 'html_tag',
+        '#tag' => 'div',
+        //this text is auto-XSS escaped.  See docs for @RenderElement("html_tag")
+        '#value' => $item->value,
+        // Let's give the note a nice sticky-note CSS appearance.
+        '#attributes' => array(
+          'class' => 'stickynote',
+        ),
+        // ..And this is the CSS for the stickynote.
+        '#attached' => array(
+          'library' => array('field_permission_example/fieldnote_sticky'),
+        ),
+      );
+    }
+    
+    return $elements;
+  }
+
+}
diff --git a/field_permission_example/src/Plugin/Field/FieldType/FieldNote.php b/field_permission_example/src/Plugin/Field/FieldType/FieldNote.php
new file mode 100644
index 0000000..bdccde4
--- /dev/null
+++ b/field_permission_example/src/Plugin/Field/FieldType/FieldNote.php
@@ -0,0 +1,60 @@
+<?php
+
+/**
+ * @file
+ * Contains Drupal\field_permission_example\Plugin\Field\FieldType\FieldNote.
+ */
+
+namespace Drupal\field_permission_example\Plugin\Field\FieldType;
+
+use Drupal\Core\Field\FieldItemBase;
+use Drupal\Core\Field\FieldDefinitionInterface;
+use Drupal\Core\Field\FieldStorageDefinitionInterface;
+use Drupal\Core\TypedData\DataDefinition;
+
+/**
+ * Plugin implementation of the 'field_permission_example' field type.
+ *
+ * @FieldType(
+ *   id = "field_permission_example_fieldnote",
+ *   label = @Translation("Example FieldNote"),
+ *   module = "field_permission_example",
+ *   description = @Translation("Demonstrates a field simple field note type with permission-based access control."),
+ *   default_widget = "field_permission_example_widget",
+ *   default_formatter = "field_permission_example_simple_formatter"
+ * )
+ */
+class FieldNote extends FieldItemBase {
+  /**
+   * {@inheritdoc}
+   */
+  public static function schema(FieldStorageDefinitionInterface $field_definition) {
+    return array(
+      'columns' => array(
+        'value' => array(
+          'type' => 'text',
+          'size' => 'normal',
+          'not null' => FALSE,
+        ),
+      ),
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function isEmpty() {
+    $value = $this->get('value')->getValue();
+    return $value === NULL || $value === '';
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function propertyDefinitions(FieldStorageDefinitionInterface $field_definition) {
+    $properties['value'] = DataDefinition::create('string')
+      ->setLabel(t('Field Note'));
+
+    return $properties;
+  }
+}
diff --git a/field_permission_example/src/Plugin/Field/FieldWidget/TextWidget.php b/field_permission_example/src/Plugin/Field/FieldWidget/TextWidget.php
new file mode 100644
index 0000000..1cf08db
--- /dev/null
+++ b/field_permission_example/src/Plugin/Field/FieldWidget/TextWidget.php
@@ -0,0 +1,40 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\field_permission_example\Plugin\field\widget\TextWidget.
+ */
+
+namespace Drupal\field_permission_example\Plugin\Field\FieldWidget;
+
+use Drupal\Core\Field\FieldItemListInterface;
+use Drupal\Core\Field\WidgetBase;
+use Drupal\Core\Form\FormStateInterface;
+
+/**
+ * Plugin implementation of the 'field_permission_example_widget' widget.
+ *
+ * @FieldWidget(
+ *   id = "field_permission_example_widget",
+ *   module = "field_permission_example",
+ *   label = @Translation("Field Note Widget"),
+ *   field_types = {
+ *     "field_permission_example_fieldnote"
+ *   }
+ * )
+ */
+class TextWidget extends WidgetBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function formElement(FieldItemListInterface $items, $delta, array $element, array &$form, FormStateInterface $form_state) {
+    $value = isset($items[$delta]->value) ? $items[$delta]->value : '';
+    $element += array(
+        '#type' => 'textarea',
+        '#default_value' => $value,
+    );
+    return array('value' => $element);
+  }
+
+}