diff --git a/example/db.sqlite3 b/example/db.sqlite3
index af6892eb..aaa854ff 100644
Binary files a/example/db.sqlite3 and b/example/db.sqlite3 differ
diff --git a/example/example/settings/base.py b/example/example/settings/base.py
index dee59f63..71c91c9b 100644
--- a/example/example/settings/base.py
+++ b/example/example/settings/base.py
@@ -56,6 +56,7 @@
     # GRAPPLE SPECIFIC MODULES
     "grapple",
     "graphene_django",
+    "django_extensions",
 ]
 
 MIDDLEWARE = [
@@ -191,3 +192,8 @@
     }
 except ImportError:
     pass
+
+
+# Query Optimization helpers
+SHELL_PLUS_PRINT_SQL = True
+RUNSERVER_PLUS_PRINT_SQL_TRUNCATE = 100000
diff --git a/example/home/migrations/0019_auto_20201124_2247.py b/example/home/migrations/0019_auto_20201124_2247.py
new file mode 100644
index 00000000..18e5ad14
--- /dev/null
+++ b/example/home/migrations/0019_auto_20201124_2247.py
@@ -0,0 +1,26 @@
+# Generated by Django 3.1.3 on 2020-11-24 22:47
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("images", "0001_initial"),
+        ("home", "0018_add_pagechooserblock"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="blogpage",
+            name="cover",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name="+",
+                to="images.customimage",
+            ),
+        ),
+    ]
diff --git a/example/home/models.py b/example/home/models.py
index ae85ed58..77b16a01 100644
--- a/example/home/models.py
+++ b/example/home/models.py
@@ -70,7 +70,7 @@ class BlogPage(HeadlessPreviewMixin, Page):
         related_name="+",
     )
     cover = models.ForeignKey(
-        "wagtailimages.Image",
+        "images.CustomImage",
         null=True,
         blank=True,
         on_delete=models.SET_NULL,
diff --git a/grapple/apps.py b/grapple/apps.py
index 43565796..f05b7ef5 100644
--- a/grapple/apps.py
+++ b/grapple/apps.py
@@ -12,6 +12,14 @@ def ready(self):
         from .actions import import_apps, load_type_fields
         from .types.streamfield import register_streamfield_blocks
 
+        self.preload_tasks()
         import_apps()
         load_type_fields()
         register_streamfield_blocks()
+
+    def preload_tasks(self):
+        # Monkeypatch Wagtails' PageQueryset .specific method to a more optimized one
+        from wagtail.core.query import PageQuerySet
+        from .db.query import specific
+
+        PageQuerySet.specific = specific
diff --git a/grapple/db/__init__.py b/grapple/db/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/grapple/db/optimizer.py b/grapple/db/optimizer.py
new file mode 100644
index 00000000..baf2af24
--- /dev/null
+++ b/grapple/db/optimizer.py
@@ -0,0 +1,256 @@
+import re
+from django.db.models.fields.related_descriptors import (
+    ReverseOneToOneDescriptor,
+    ReverseOneToOneDescriptor,
+)
+from graphene.types.definitions import GrapheneInterfaceType
+from graphql.language.ast import Field, InlineFragment, FragmentSpread
+
+from modelcluster.fields import ParentalKey
+
+pascal_to_snake = re.compile(r"(?<!^)(?=[A-Z])")
+
+
+class QueryOptimizer:
+    # Fields extracted from AST that the request wants
+    qs = None
+    schema = None
+    model = None
+    model_type_map = {}
+    query_fields = []
+
+    def __init__(self):
+        # Queryset specific lists (for this query)
+        self.only_fields = []
+        self.select_related_fields = []
+        self.prefetch_related_fields = []
+        # Future Optimization maps
+        self.only_field_types = {}
+        self.select_related_types = {}
+        self.prefetch_related_types = {}
+
+    @staticmethod
+    def query(qs, info):
+        # Create new optimizer instance.
+        qs_optimizer = QueryOptimizer()
+        qs_optimizer.qs = qs
+        qs_optimizer.schema = info.schema
+        qs_optimizer.model = qs.model
+        # Extract what fields the user wants from the AST.
+        fields, types = AstExplorer(qs, info).parse_ast()
+        qs_optimizer.query_fields = fields
+        qs_optimizer.model_type_map = types
+        # Sort desired fields in how we preload them.
+        qs_optimizer.sort_fields()
+        # Add deferred fields to query.
+        qs_optimizer.optimise_fields()
+        # return the new optimized query
+        return qs_optimizer.qs
+
+    # Sort the requested fields, depending on relation to model.
+    def sort_fields(self):
+        for field_name in self.query_fields or []:
+            # Make sure field name is snake not pascal (graphene converts them that way)
+            field_name = pascal_to_snake.sub("_", field_name).lower()
+
+            # Ignore typename that causes null error
+            if field_name == "__typename":
+                continue
+
+            # Support using simple field
+            field = getattr(self.model, field_name, None)
+            if field:
+                self.select_field(field, field_name)
+                continue
+
+            # Support more complex sub-selectable fields
+            try:
+                field_name_prefix, field_name = field_name.split("__", 1)
+                nested_field = getattr(self.model, field_name_prefix)
+                if nested_field:
+                    # Add to query to save recomputing down the line
+                    self.select_field(nested_field, field_name, field_name_prefix)
+                    continue
+            except:
+                pass
+
+    def select_field(self, field, field_name, field_name_prefix=None):
+        model = self.model_type_map.get(field_name_prefix, None)
+        # If link to another model is here then try and parse nested fields
+        if isinstance(field, ReverseOneToOneDescriptor):
+            # Recursion to load nested fields to support specific pages
+            nested_field_name = field_name.split("__")[0]
+            nested_field = getattr(model, nested_field_name, None)
+            if hasattr(nested_field, "field"):
+                return self.select_field(
+                    nested_field.field, nested_field_name, field_name_prefix
+                )
+            else:
+                return self.select_field(
+                    nested_field, nested_field_name, field_name_prefix
+                )
+
+        # Property's or functions can't be selected so we just add id so the query always runs
+        if hasattr(model, "id"):
+            self.only_fields.append("id")
+
+        # Don't select property functions
+        if isinstance(field, property):
+            return
+
+        # Don't select method functions
+        if callable(field):
+            return
+
+        if not getattr(field, "is_relation", False):
+            if model:
+                # Cache selection for future optimization (query.py)
+                existing_fields = self.only_field_types.get(field_name_prefix, [])
+                self.only_field_types[field_name_prefix] = [
+                    field_name,
+                    *existing_fields,
+                ]
+            else:
+                self.only_fields.append(field_name)
+
+        elif field.one_to_many or field.many_to_many or isinstance(field, ParentalKey):
+            if model:
+                # Cache selection for future optimization (query.py)
+                existing_fields = self.prefetch_related_types.get(field_name_prefix, [])
+                self.prefetch_related_types[field_name_prefix] = [
+                    field_name,
+                    *existing_fields,
+                ]
+            else:
+                self.prefetch_related_fields.append(field_name)
+
+        elif field.many_to_one or field.one_to_one:
+            if model:
+                # Cache selection for future optimization (query.py)
+                existing_fields = self.select_related_types.get(field_name_prefix, [])
+                self.select_related_types[field_name_prefix] = [
+                    field_name,
+                    *existing_fields,
+                ]
+            else:
+                self.only_fields.append(field_name)
+                self.select_related_fields.append(field_name)
+
+    # Apply order fields to querysets
+    def optimise_fields(self):
+        self.qs = self.qs.only(*self.only_fields)
+        self.qs = self.qs.select_related(*self.select_related_fields)
+        self.qs = self.qs.prefetch_related(*self.prefetch_related_fields)
+
+        # Add custom lists to query for use in Specific page optimizer.
+        setattr(self.qs.query, "only_field_types", self.only_field_types)
+        setattr(self.qs.query, "select_related_types", self.select_related_types)
+        setattr(self.qs.query, "prefetch_related_types", self.prefetch_related_types)
+
+
+class AstExplorer:
+    schema = None
+    fragments = {}
+    model_type_map = {}
+    resolve_info = None
+
+    def __init__(self, qs, info):
+        self.schema = info.schema
+        self.resolve_info = info
+        self.fragments = info.fragments
+
+    # Parse AST to find fields
+    def parse_ast(self):
+        pages_interface = self.get_pages_interface()
+        return self.parse_field(pages_interface, None), self.model_type_map
+
+    # Return the pages interface, we only optimise that for now
+    def get_pages_interface(self):
+        for field in self.resolve_info.field_asts:
+            if field.name.value == "page":
+                return field
+            if field.name.value == "pages":
+                return field
+
+    def parse_field(self, field, field_prefix):
+        # Don't crash if the field isn't parsable...
+        if field is None:
+            return
+
+        field_name = field.name.value
+
+        # If field has subset fields
+        if field.selection_set:
+            field_prefix = field_prefix + "__" + field_name if field_prefix else ""
+            return self.parse_selection_set(field.selection_set, field_prefix)
+
+        # Prefix this fieldname with that of it's parent
+        if field_prefix:
+            return field_prefix + "__" + field.name.value
+
+        # Return fields name
+        return field_name
+
+    def parse_selection_set(self, selection_set, field_prefix):
+        selections = []
+        if selection_set.selections:
+            for selection in selection_set.selections:
+                selection = self.parse_selection(selection, field_prefix)
+                if isinstance(selection, list):
+                    selections.extend(selection)
+                else:
+                    selections.append(selection)
+
+        return selections
+
+    def parse_selection(self, selection, field_prefix):
+        if isinstance(selection, InlineFragment):
+            return self.parse_inline_fragment(selection, field_prefix)
+
+        if isinstance(selection, FragmentSpread):
+            return self.parse_fragment_spread(selection, field_prefix)
+
+        if isinstance(selection, Field):
+            return self.parse_field(selection, field_prefix)
+
+    def parse_fragment_spread(self, fragment_spread, field_prefix):
+        # Get fragment name.
+        fragment_name = fragment_spread.name.value
+
+        # Get fragment type from name and return it parsed.
+        fragment_type = self.fragments[fragment_name]
+        return self.parse_inline_fragment(
+            fragment_type, field_prefix, is_fragment_spread=True
+        )
+
+    def parse_inline_fragment(
+        self, inline_fragment, field_prefix, is_fragment_spread=False
+    ):
+        # Get type of inline fragment
+        gql_type_name = inline_fragment.type_condition.name.value
+        gql_type = self.schema.get_type(gql_type_name)
+
+        # Record what Django model this correlates to
+        type_prefix = gql_type_name.lower()
+        self.model_type_map[type_prefix] = getattr(
+            gql_type.graphene_type._meta, "model", None
+        )
+
+        # Function to add the typename to fieldnames
+        def prefix_type(field):
+            # Don't prefix if the type is an interface
+            if not isinstance(gql_type, GrapheneInterfaceType) and field_prefix:
+                return field_prefix + "__" + field
+
+            return field
+
+        # Get fields of inline fragment
+        selections = []
+        if inline_fragment.selection_set:
+            selections = self.parse_selection_set(
+                inline_fragment.selection_set,
+                field_prefix if is_fragment_spread else type_prefix,
+            )
+            selections = list(map(prefix_type, selections))
+
+        return selections
diff --git a/grapple/db/query.py b/grapple/db/query.py
new file mode 100644
index 00000000..06a75939
--- /dev/null
+++ b/grapple/db/query.py
@@ -0,0 +1,88 @@
+from collections import defaultdict
+
+from wagtail.core.query import DeferredSpecificIterable
+from django.contrib.contenttypes.models import ContentType
+from django.db.models.query import BaseIterable
+
+
+def specific(self, defer=False, *args, **kwargs):
+    """
+    This efficiently gets all the specific pages for the queryset, using
+    the minimum number of queries.
+
+    When the "defer" keyword argument is set to True, only the basic page
+    fields will be loaded and all specific fields will be deferred. It
+    will still generate a query for each page type though (this may be
+    improved to generate only a single query in a future release).
+    """
+    clone = self._clone()
+    if defer:
+        clone._iterable_class = GrappleSpecificIterable
+    else:
+        clone._iterable_class = DeferredSpecificIterable
+
+    return clone
+
+
+class GrappleSpecificIterable(BaseIterable):
+    def __iter__(self):
+        return specific_iterator(self.queryset, defer=True)
+
+
+# Custom version of code from https://github.com/wagtail/wagtail/blob/master/wagtail/core/query.py#L363
+def specific_iterator(qs, defer=True):
+    """
+    This efficiently iterates all the specific pages in a queryset, using
+    the minimum number of queries.
+
+    This should be called from ``PageQuerySet.specific``
+    """
+    pks_and_types = qs.values_list("pk", "content_type")
+    pks_by_type = defaultdict(list)
+    for pk, content_type in pks_and_types:
+        pks_by_type[content_type].append(pk)
+
+    # Content types are cached by ID, so this will not run any queries.
+    content_types = {pk: ContentType.objects.get_for_id(pk) for _, pk in pks_and_types}
+
+    # Get the specific instances of all pages, one model class at a time.
+    pages_by_type = {}
+    for content_type, pks in pks_by_type.items():
+        # look up model class for this content type, falling back on the original
+        # model (i.e. Page) if the more specific one is missing
+        specific_model = content_types[content_type].model_class() or qs.model
+        specific_model_name = specific_model.__name__.lower()
+
+        # Get deffered fields (.only/.deffer)
+        only_fields, _ = qs.query.deferred_loading
+        only_fields_specific = getattr(qs.query, "only_field_types", {}).get(
+            specific_model_name, []
+        )
+        select_related_fields = getattr(qs.query, "select_related_types", {}).get(
+            specific_model_name, []
+        )
+        prefetch_related_fields = getattr(qs.query, "prefetch_related_types", {}).get(
+            specific_model_name, []
+        )
+
+        # If no fields of this model requested then don't query specific
+        if not only_fields:
+            pages_by_type[content_type] = None
+            continue
+
+        # Query pages
+        pages = specific_model.objects.filter(pk__in=pks)
+        # Defer all fields apart from those required
+        pages = pages.only(*only_fields, *only_fields_specific, *select_related_fields)
+        # Apply select_related fields (passed down from optimizer.py)
+        pages = pages.select_related(*select_related_fields)
+        # Apply prefetch_related fields (passed down from optimizer.py)
+        pages = pages.prefetch_related(*prefetch_related_fields)
+
+        # Replace specific models in same sort order
+        pages_by_type[content_type] = {page.pk: page for page in pages}
+
+    # Yield all of the pages (specific + generic), in the order they occurred in the original query.
+    for pk, content_type in pks_and_types:
+        if pages_by_type[content_type]:
+            yield pages_by_type[content_type][pk]
diff --git a/grapple/types/pages.py b/grapple/types/pages.py
index fc1e7601..c5ec8ce1 100644
--- a/grapple/types/pages.py
+++ b/grapple/types/pages.py
@@ -16,6 +16,7 @@
 
 from ..registry import registry
 from ..utils import resolve_queryset
+from ..db.optimizer import QueryOptimizer
 from .structures import QuerySetList
 
 
@@ -157,33 +158,40 @@ class Meta:
         interfaces = (PageInterface,)
 
 
-def get_specific_page(id, slug, token, content_type=None, site=None):
+def get_specific_page(id, slug, token, content_type=None, site=None, info=None):
     """
     Get a specific page, given a page_id, slug or preview if a preview token is passed
     """
     page = None
     try:
-        qs = WagtailPage.objects.live().public().specific()
+        # Generate queryset based on given key & Optimise query based on request AST
+        pages = WagtailPage.objects.live().public()
+        pages = QueryOptimizer.query(pages, info)
 
         if site:
-            qs = qs.in_site(site)
+            pages = pages.in_site(site)
 
         if id:
-            page = qs.get(pk=id)
+            page = pages.get(id=id)
         elif slug:
-            page = qs.get(slug=slug)
+            page = pages.get(slug=slug)
+
+        if page:
+            page = page.specific
 
         if token:
             if page:
                 page_type = type(page)
                 if hasattr(page_type, "get_page_from_preview_token"):
                     page = page_type.get_page_from_preview_token(token)
+
             elif content_type:
                 app_label, model = content_type.lower().split(".")
                 mdl = ContentType.objects.get(app_label=app_label, model=model)
                 cls = mdl.model_class()
                 if hasattr(cls, "get_page_from_preview_token"):
                     page = cls.get_page_from_preview_token(token)
+
     except BaseException:
         page = None
 
@@ -212,7 +220,7 @@ class Mixin:
 
         # Return all pages in site, ideally specific.
         def resolve_pages(self, info, **kwargs):
-            pages = WagtailPage.objects.live().public().specific()
+            pages = WagtailPage.objects.live().public().specific(defer=True)
 
             if kwargs.get("in_site", False):
                 site = Site.find_for_request(info.context)
@@ -230,6 +238,7 @@ def resolve_page(self, info, **kwargs):
                 site=Site.find_for_request(info.context)
                 if kwargs.get("in_site", False)
                 else None,
+                info=info,
             )
 
     return Mixin
@@ -247,10 +256,14 @@ def on_updated(sender, token, **kwargs):
 
     # Subscription Mixin
     def PagesSubscription():
-        def preview_observable(id, slug, token, content_type):
+        def preview_observable(id, slug, token, content_type, site, info):
             return preview_subject.filter(
                 lambda previewToken: previewToken == token
-            ).map(lambda token: get_specific_page(id, slug, token, content_type))
+            ).map(
+                lambda token: get_specific_page(
+                    id, slug, token, content_type, site, info
+                )
+            )
 
         class Mixin:
             page = graphene.Field(
@@ -267,6 +280,10 @@ def resolve_page(self, info, **kwargs):
                     slug=kwargs.get("slug"),
                     token=kwargs.get("token"),
                     content_type=kwargs.get("content_type"),
+                    site=Site.find_for_request(info.context)
+                    if kwargs.get("in_site", False)
+                    else None,
+                    info=info,
                 )
 
         return Mixin
diff --git a/grapple/utils.py b/grapple/utils.py
index 2805ca22..00a1f692 100644
--- a/grapple/utils.py
+++ b/grapple/utils.py
@@ -8,16 +8,17 @@
 from wagtail.search.models import Query
 from wagtail.search.backends import get_search_backend
 
+from .db.optimizer import QueryOptimizer
 from .types.structures import BasePaginatedType, PaginationType
 
 
 def resolve_queryset(
     qs,
     info,
+    id=None,
     limit=None,
     offset=None,
     search_query=None,
-    id=None,
     order=None,
     collection=None,
     **kwargs
@@ -43,9 +44,10 @@ def resolve_queryset(
     :type collection: int
     """
     offset = int(offset or 0)
+    qs = QueryOptimizer.query(qs, info)
 
     if id is not None:
-        qs = qs.filter(pk=id)
+        qs = qs.get(id=id)
     else:
         qs = qs.all()
 
diff --git a/requirements.txt b/requirements.txt
index a4b45579..245a27d9 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -8,3 +8,4 @@ wagtail-factories==2.0.0
 django-cors-headers==3.4.0
 wagtail-headless-preview==0.1.4
 pre-commit==2.6.0
+django_extensions==2.2.9