diff --git a/panelizer.install b/panelizer.install
index e69de29..b3d9bbc 100644
--- a/panelizer.install
+++ b/panelizer.install
@@ -0,0 +1 @@
+<?php
diff --git a/panelizer.module b/panelizer.module
index dfa804f..5bd1753 100644
--- a/panelizer.module
+++ b/panelizer.module
@@ -207,6 +207,13 @@ function panelizer_panels_ipe_panels_display_presave(PanelsDisplayVariant $panel
   }
 }
 
+function panelizer_form_alter(&$form, FormStateInterface $form_state, $form_id) {
+  // @todo make this work for non-ipe scenario.
+  if ($form_id == 'panels_ipe_block_plugin_form' && !empty($form['plugin_id']['#value']) && strpos($form['plugin_id']['#value'], 'inline_content:') === 0) {
+    $form['flipper']['front']['settings']['label']['#access'] = FALSE;
+  }
+}
+
 /**
  * Implements hook_form_FORM_ID_alter().
  */
diff --git a/src/Entity/BlockContent.php b/src/Entity/BlockContent.php
new file mode 100644
index 0000000..8722970
--- /dev/null
+++ b/src/Entity/BlockContent.php
@@ -0,0 +1,71 @@
+<?php
+
+namespace Drupal\panelizer\Entity;
+
+use Drupal\block_content\Entity\BlockContent as CoreBlockContent;
+
+/**
+ * Defines the custom block entity class.
+ *
+ * @ContentEntityType(
+ *   id = "panelizer_block_content",
+ *   label = @Translation("Custom block"),
+ *   bundle_label = @Translation("Custom block type"),
+ *   handlers = {
+ *     "storage" = "Drupal\panelizer\Entity\Storage\ContentEntityNullStorage",
+ *     "access" = "Drupal\block_content\BlockContentAccessControlHandler",
+ *     "list_builder" = "Drupal\block_content\BlockContentListBuilder",
+ *     "view_builder" = "Drupal\block_content\BlockContentViewBuilder",
+ *     "views_data" = "Drupal\block_content\BlockContentViewsData",
+ *     "form" = {
+ *       "add" = "Drupal\block_content\BlockContentForm",
+ *       "edit" = "Drupal\block_content\BlockContentForm",
+ *       "delete" = "Drupal\block_content\Form\BlockContentDeleteForm",
+ *       "default" = "Drupal\block_content\BlockContentForm"
+ *     },
+ *     "translation" = "Drupal\block_content\BlockContentTranslationHandler"
+ *   },
+ *   admin_permission = "administer blocks",
+ *   base_table = "block_content",
+ *   revision_table = "block_content_revision",
+ *   data_table = "block_content_field_data",
+ *   links = {
+ *     "canonical" = "/block/{block_content}",
+ *     "delete-form" = "/block/{block_content}/delete",
+ *     "edit-form" = "/block/{block_content}",
+ *     "collection" = "/admin/structure/block/block-content",
+ *   },
+ *   translatable = TRUE,
+ *   entity_keys = {
+ *     "id" = "id",
+ *     "revision" = "revision_id",
+ *     "bundle" = "type",
+ *     "label" = "info",
+ *     "langcode" = "langcode",
+ *     "uuid" = "uuid"
+ *   },
+ *   bundle_entity_type = "block_content_type",
+ *   field_ui_base_route = "entity.block_content_type.edit_form",
+ *   render_cache = FALSE,
+ *   multiversion = FALSE,
+ * )
+ */
+class BlockContent extends CoreBlockContent {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function __construct(array $values, $entity_type, $bundle = FALSE, array $translations = []) {
+    parent::__construct($values, 'block_content', $bundle, $translations);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function save() {
+    return $this->entityTypeManager()
+      ->getStorage('panelizer_block_content')
+      ->save($this);
+  }
+
+}
diff --git a/src/Entity/Storage/ContentEntityNullStorage.php b/src/Entity/Storage/ContentEntityNullStorage.php
new file mode 100644
index 0000000..c98363f
--- /dev/null
+++ b/src/Entity/Storage/ContentEntityNullStorage.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace Drupal\panelizer\Entity\Storage;
+
+use Drupal\Core\Entity\ContentEntityInterface;
+use Drupal\Core\Entity\Sql\SqlContentEntityStorage;
+
+/**
+ * A content entity storage that does everything except write to the database.
+ */
+class ContentEntityNullStorage extends SqlContentEntityStorage {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function doSaveFieldItems(ContentEntityInterface $entity, array $names = []) {
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function saveToSharedTables(ContentEntityInterface $entity, $table_name = NULL, $new_revision = NULL) {
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function saveToDedicatedTables(ContentEntityInterface $entity, $update = TRUE, $names = array()) {
+  }
+
+}
diff --git a/src/Plugin/Block/InlineBlock.php b/src/Plugin/Block/InlineBlock.php
new file mode 100644
index 0000000..d8f87e6
--- /dev/null
+++ b/src/Plugin/Block/InlineBlock.php
@@ -0,0 +1,116 @@
+<?php
+
+namespace Drupal\panelizer\Plugin\Block;
+
+use Drupal\block_content\Plugin\Block\BlockContentBlock;
+use Drupal\Core\Block\BlockManagerInterface;
+use Drupal\Core\Entity\EntityManagerInterface;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\Core\Language\LanguageManagerInterface;
+use Drupal\Core\Routing\UrlGeneratorInterface;
+use Drupal\Core\Session\AccountInterface;
+use Drupal\panelizer\Entity\BlockContent;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * Defines a generic custom block type.
+ *
+ * @Block(
+ *  id = "inline_content",
+ *  admin_label = @Translation("Inline block"),
+ *  category = @Translation("Custom"),
+ *  deriver = "Drupal\panelizer\Plugin\Derivative\InlineBlock"
+ * )
+ */
+class InlineBlock extends BlockContentBlock {
+
+
+  /**
+   * @var \Drupal\panelizer\Entity\BlockContent
+   */
+  protected $entity;
+
+  /**
+   * An array of all the parents set within the entity form.
+   *
+   * @var array
+   */
+  protected $parents;
+
+  public function __construct(array $configuration, $plugin_id, $plugin_definition, BlockManagerInterface $block_manager, EntityManagerInterface $entity_manager, AccountInterface $account, UrlGeneratorInterface $url_generator) {
+    $entity = !empty($configuration['entity']) ? $configuration['entity'] : NULL;
+    unset($configuration['entity']);
+    parent::__construct($configuration, $plugin_id, $plugin_definition, $block_manager, $entity_manager, $account, $url_generator);
+    if ($entity) {
+      $this->entity = unserialize($entity);
+    }
+    else {
+      $bundle = $this->getDerivativeId();
+      $this->entity = new BlockContent([], 'block_content', $bundle);
+    }
+  }
+
+  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
+    return new static(
+      $configuration,
+      $plugin_id,
+      $plugin_definition,
+      $container->get('plugin.manager.block'),
+      $container->get('entity.manager'),
+      $container->get('current_user'),
+      $container->get('url_generator')
+    );
+
+  }
+
+
+  protected function getEntity() {
+    return $this->entity;
+  }
+
+  public function getConfiguration() {
+    $configuration = parent::getConfiguration();
+    $configuration['entity'] = serialize($this->getEntity());
+    return $configuration;
+  }
+
+  public function blockForm($form, FormStateInterface $form_state) {
+    $options = $this->entityManager->getViewModeOptionsByBundle('panelizer_block_content', $this->getDerivativeId());
+    $form['view_mode'] = array(
+      '#type' => 'select',
+      '#options' => $options,
+      '#title' => $this->t('View mode'),
+      '#description' => $this->t('Output the block in this view mode.'),
+      '#default_value' => $this->configuration['view_mode'],
+      '#access' => (count($options) > 1),
+    );
+    $form['title']['#description'] = $this->t('The title of the block as shown to the user.');
+    $entity = $this->getEntity();
+    if (!$entity->info->getValue()) {
+      $entity = NULL;
+    }
+    $form['entity'] = [
+      '#type' => 'inline_entity_form',
+      '#entity_type' => 'panelizer_block_content',
+      '#bundle' => $this->getDerivativeId(),
+      // If the #default_value is NULL, a new entity will be created.
+      '#default_value' => $entity,
+    ];
+    return $form;
+  }
+
+  public function blockSubmit($form, FormStateInterface $form_state) {
+    parent::blockSubmit($form, $form_state);
+    $entity = $form['entity']['#entity'];
+    $this->configuration['label'] = $entity->label();
+    $langcode = $form_state->getValue('langcode');
+    $this->configuration['langcode'] = $langcode;
+    foreach ($entity->toArray() as $key => $value) {
+      if ($form_state->hasValue(['entity', $key])) {
+        $entity->{$key} = $form_state->getValue(['entity', $key]);
+      }
+    }
+    $this->entity = $entity;
+  }
+
+}
\ No newline at end of file
diff --git a/src/Plugin/Derivative/InlineBlock.php b/src/Plugin/Derivative/InlineBlock.php
new file mode 100644
index 0000000..0e752a9
--- /dev/null
+++ b/src/Plugin/Derivative/InlineBlock.php
@@ -0,0 +1,68 @@
+<?php
+
+namespace Drupal\panelizer\Plugin\Derivative;
+
+use Drupal\Component\Plugin\Derivative\DeriverBase;
+use Drupal\Core\Entity\EntityStorageInterface;
+use Drupal\Core\Plugin\Discovery\ContainerDeriverInterface;
+use Drupal\Core\StringTranslation\TranslationManager;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * Retrieves bundle types for inline blocks.
+ */
+class InlineBlock extends DeriverBase implements ContainerDeriverInterface {
+
+  /**
+   * The custom block type storage.
+   *
+   * @var \Drupal\Core\Entity\EntityStorageInterface
+   */
+  protected $blockContentTypeStorage;
+
+  /**
+   * @var \Drupal\Core\StringTranslation\TranslationManager
+   */
+  protected $translation;
+
+  /**
+   * Constructs a BlockContentType object.
+   *
+   * @param \Drupal\Core\Entity\EntityStorageInterface $block_content_type_storage
+   *   The custom block storage.
+   */
+  public function __construct(EntityStorageInterface $block_content_type_storage, TranslationManager $translation) {
+    $this->blockContentTypeStorage = $block_content_type_storage;
+    $this->translation = $translation;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container, $base_plugin_id) {
+    $entity_manager = $container->get('entity.manager');
+    return new static(
+      $entity_manager->getStorage('block_content_type'),
+      $container->get('string_translation')
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getDerivativeDefinitions($base_plugin_definition) {
+    $block_types = $this->blockContentTypeStorage->loadMultiple();
+    // Reset the discovered definitions.
+    $this->derivatives = [];
+    /** @var $type \Drupal\block_content\Entity\BlockContent */
+    foreach ($block_types as $type) {
+      $this->derivatives[$type->id()] = $base_plugin_definition;
+      $this->derivatives[$type->id()]['admin_label'] = $this->translation->translate('Inline @type', ['@type' => $type->label()]);
+      $this->derivatives[$type->id()]['config_dependencies']['content'] = array(
+        $type->getConfigDependencyName()
+      );
+    }
+    return $this->derivatives;
+  }
+
+}
diff --git a/tests/src/Kernel/BlockContentTest.php b/tests/src/Kernel/BlockContentTest.php
new file mode 100644
index 0000000..c30cdd6
--- /dev/null
+++ b/tests/src/Kernel/BlockContentTest.php
@@ -0,0 +1,85 @@
+<?php
+
+namespace Drupal\Tests\panelizer\Kernel;
+
+use Drupal\KernelTests\KernelTestBase;
+
+/**
+ * @group panelizer
+ */
+class BlockContentTest extends KernelTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = [
+    'block',
+    'block_content',
+    'ctools',
+    'field',
+    'field_ui',
+    'panelizer',
+    'panels',
+    'text',
+    'user',
+  ];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+
+    $this->container->get('entity_type.manager')
+      ->getStorage('block_content_type')
+      ->create([
+        'id' => 'test_type',
+        'label' => 'Test block type',
+      ])
+      ->save();
+
+    $field_storage = $this->container->get('entity_type.manager')
+      ->getStorage('field_storage_config')
+      ->create([
+        'field_name' => 'body',
+        'entity_type' => 'block_content',
+        'type' => 'text_with_summary',
+      ]);
+    $field_storage->save();
+
+    $this->container->get('entity_type.manager')
+      ->getStorage('field_config')
+      ->create([
+        'field_storage' => $field_storage,
+        'bundle' => 'test_type',
+      ])
+      ->save();
+  }
+
+  public function testBlockWithField() {
+    $body = $this->randomMachineName(32);
+
+    $block_content = $this->container->get('entity_type.manager')
+      ->getStorage('panelizer_block_content')
+      ->create([
+        'type' => 'test_type',
+        'info' => 'A test of a Panelizer block_content entity.',
+        'body' => $body,
+      ]);
+
+    $this->assertTrue($block_content->hasField('body'));
+    $this->assertEquals($body, $block_content->body->value);
+
+    $block_content->save();
+    $this->assertEquals($body, $block_content->body->value);
+
+    // The table should be empty.
+    $count = $this->container->get('database')
+      ->select('block_content__body')
+      ->countQuery()
+      ->execute()
+      ->fetchField();
+    $this->assertEmpty($count);
+  }
+
+}