diff --git a/hugolib/page.go b/hugolib/page.go
index fd6278bb443..170c15dddf6 100644
--- a/hugolib/page.go
+++ b/hugolib/page.go
@@ -1,4 +1,4 @@
-// Copyright 2016 The Hugo Authors. All rights reserved.
+// Copyright 2018 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -25,6 +25,7 @@ import (
 	"github.com/bep/gitmap"
 
 	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugolib/pagemeta"
 	"github.com/gohugoio/hugo/resource"
 
 	"github.com/gohugoio/hugo/output"
@@ -140,9 +141,6 @@ type Page struct {
 	Draft     bool
 	Status    string
 
-	PublishDate time.Time
-	ExpiryDate  time.Time
-
 	// PageMeta contains page stats such as word count etc.
 	PageMeta
 
@@ -223,11 +221,12 @@ type Page struct {
 	Keywords    []string
 	Data        map[string]interface{}
 
-	Date    time.Time
-	Lastmod time.Time
+	pagemeta.PageDates
 
 	Sitemap Sitemap
-	URLPath
+	pagemeta.URLPath
+	frontMatterURL string
+
 	permalink    string
 	relPermalink string
 
@@ -1115,12 +1114,44 @@ func (p *Page) update(frontmatter map[string]interface{}) error {
 	// Needed for case insensitive fetching of params values
 	helpers.ToLowerMap(frontmatter)
 
-	var modified time.Time
+	var mtime time.Time
+	if p.Source.FileInfo() != nil {
+		mtime = p.Source.FileInfo().ModTime()
+	}
+
+	descriptor := pagemeta.FrontMatterDescriptor{
+		Frontmatter:  frontmatter,
+		Params:       p.params,
+		Dates:        &p.PageDates,
+		PageURLs:     &p.URLPath,
+		BaseFilename: p.BaseFileName(),
+		ModTime:      mtime}
+
+	// Handle the date separately
+	// TODO(bep) we need to "do more" in this area so this can be split up and
+	// more easily tested without the Page, but the coupling is strong.
+	err := p.s.frontmatterHandler.HandleDates(descriptor)
+	if err != nil {
+		p.s.Log.ERROR.Printf("Failed to handle dates for page %q: %s", p.Path(), err)
+	}
 
-	var err error
 	var draft, published, isCJKLanguage *bool
 	for k, v := range frontmatter {
 		loki := strings.ToLower(k)
+
+		if loki == "published" { // Intentionally undocumented
+			vv, err := cast.ToBoolE(v)
+			if err == nil {
+				published = &vv
+			}
+			// published may also be a date
+			continue
+		}
+
+		if p.s.frontmatterHandler.IsDateKey(loki) {
+			continue
+		}
+
 		switch loki {
 		case "title":
 			p.title = cast.ToString(v)
@@ -1139,7 +1170,7 @@ func (p *Page) update(frontmatter map[string]interface{}) error {
 				return fmt.Errorf("Only relative URLs are supported, %v provided", url)
 			}
 			p.URLPath.URL = cast.ToString(v)
-			p.URLPath.frontMatterURL = p.URLPath.URL
+			p.frontMatterURL = p.URLPath.URL
 			p.params[loki] = p.URLPath.URL
 		case "type":
 			p.contentType = cast.ToString(v)
@@ -1150,12 +1181,6 @@ func (p *Page) update(frontmatter map[string]interface{}) error {
 		case "keywords":
 			p.Keywords = cast.ToStringSlice(v)
 			p.params[loki] = p.Keywords
-		case "date":
-			p.Date, err = cast.ToTimeE(v)
-			if err != nil {
-				p.s.Log.ERROR.Printf("Failed to parse date '%v' in page %s", v, p.File.Path())
-			}
-			p.params[loki] = p.Date
 		case "headless":
 			// For now, only the leaf bundles ("index.md") can be headless (i.e. produce no output).
 			// We may expand on this in the future, but that gets more complex pretty fast.
@@ -1163,19 +1188,6 @@ func (p *Page) update(frontmatter map[string]interface{}) error {
 				p.headless = cast.ToBool(v)
 			}
 			p.params[loki] = p.headless
-		case "lastmod":
-			p.Lastmod, err = cast.ToTimeE(v)
-			if err != nil {
-				p.s.Log.ERROR.Printf("Failed to parse lastmod '%v' in page %s", v, p.File.Path())
-			}
-		case "modified":
-			vv, err := cast.ToTimeE(v)
-			if err == nil {
-				p.params[loki] = vv
-				modified = vv
-			} else {
-				p.params[loki] = cast.ToString(v)
-			}
 		case "outputs":
 			o := cast.ToStringSlice(v)
 			if len(o) > 0 {
@@ -1190,34 +1202,9 @@ func (p *Page) update(frontmatter map[string]interface{}) error {
 				}
 
 			}
-		case "publishdate", "pubdate":
-			p.PublishDate, err = cast.ToTimeE(v)
-			if err != nil {
-				p.s.Log.ERROR.Printf("Failed to parse publishdate '%v' in page %s", v, p.File.Path())
-			}
-			p.params[loki] = p.PublishDate
-		case "expirydate", "unpublishdate":
-			p.ExpiryDate, err = cast.ToTimeE(v)
-			if err != nil {
-				p.s.Log.ERROR.Printf("Failed to parse expirydate '%v' in page %s", v, p.File.Path())
-			}
 		case "draft":
 			draft = new(bool)
 			*draft = cast.ToBool(v)
-		case "published": // Intentionally undocumented
-			vv, err := cast.ToBoolE(v)
-			if err == nil {
-				published = &vv
-			} else {
-				// Some sites use this as the publishdate
-				vv, err := cast.ToTimeE(v)
-				if err == nil {
-					p.PublishDate = vv
-					p.params[loki] = p.PublishDate
-				} else {
-					p.params[loki] = cast.ToString(v)
-				}
-			}
 		case "layout":
 			p.Layout = cast.ToString(v)
 			p.params[loki] = p.Layout
@@ -1333,32 +1320,6 @@ func (p *Page) update(frontmatter map[string]interface{}) error {
 	}
 	p.params["draft"] = p.Draft
 
-	if p.Date.IsZero() {
-		p.Date = p.PublishDate
-	}
-
-	if p.PublishDate.IsZero() {
-		p.PublishDate = p.Date
-	}
-
-	if p.Date.IsZero() && p.s.Cfg.GetBool("useModTimeAsFallback") {
-		p.Date = p.Source.FileInfo().ModTime()
-	}
-
-	if p.Lastmod.IsZero() {
-		if !modified.IsZero() {
-			p.Lastmod = modified
-		} else {
-			p.Lastmod = p.Date
-		}
-
-	}
-
-	p.params["date"] = p.Date
-	p.params["lastmod"] = p.Lastmod
-	p.params["publishdate"] = p.PublishDate
-	p.params["expirydate"] = p.ExpiryDate
-
 	if isCJKLanguage != nil {
 		p.isCJKLanguage = *isCJKLanguage
 	} else if p.s.Cfg.GetBool("hasCJKLanguage") {
@@ -1865,14 +1826,6 @@ func (p *Page) String() string {
 	return fmt.Sprintf("Page(%q)", p.title)
 }
 
-type URLPath struct {
-	URL            string
-	frontMatterURL string
-	Permalink      string
-	Slug           string
-	Section        string
-}
-
 // Scratch returns the writable context associated with this Page.
 func (p *Page) Scratch() *Scratch {
 	if p.scratch == nil {
diff --git a/hugolib/page_paths.go b/hugolib/page_paths.go
index 5f45f7adf5a..13aebcd9120 100644
--- a/hugolib/page_paths.go
+++ b/hugolib/page_paths.go
@@ -88,7 +88,7 @@ func (p *Page) initTargetPathDescriptor() error {
 		Sections:    p.sections,
 		UglyURLs:    p.s.Info.uglyURLs(p),
 		Dir:         filepath.ToSlash(p.Source.Dir()),
-		URL:         p.URLPath.frontMatterURL,
+		URL:         p.frontMatterURL,
 		IsMultihost: p.s.owner.IsMultihost(),
 	}
 
diff --git a/hugolib/page_test.go b/hugolib/page_test.go
index 814556c6c59..dc4fcb60eeb 100644
--- a/hugolib/page_test.go
+++ b/hugolib/page_test.go
@@ -1,4 +1,4 @@
-// Copyright 2015 The Hugo Authors. All rights reserved.
+// Copyright 2018 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -27,8 +27,6 @@ import (
 
 	"github.com/gohugoio/hugo/deps"
 	"github.com/gohugoio/hugo/helpers"
-	"github.com/gohugoio/hugo/hugofs"
-	"github.com/gohugoio/hugo/source"
 	"github.com/spf13/cast"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -728,6 +726,7 @@ func TestPageWithDelimiterForMarkdownThatCrossesBorder(t *testing.T) {
 }
 
 // Issue #3854
+// Also see https://github.com/gohugoio/hugo/issues/3977
 func TestPageWithDateFields(t *testing.T) {
 	assert := require.New(t)
 	pageWithDate := `---
@@ -737,8 +736,8 @@ weight: %d
 ---
 Simple Page With Some Date`
 
-	hasBothDates := func(p *Page) bool {
-		return p.Date.Year() == 2017 && p.PublishDate.Year() == 2017
+	hasDate := func(p *Page) bool {
+		return p.Date.Year() == 2017
 	}
 
 	datePage := func(field string, weight int) string {
@@ -749,7 +748,7 @@ Simple Page With Some Date`
 	assertFunc := func(t *testing.T, ext string, pages Pages) {
 		assert.True(len(pages) > 0)
 		for _, p := range pages {
-			assert.True(hasBothDates(p))
+			assert.True(hasDate(p))
 		}
 
 	}
@@ -985,8 +984,64 @@ Page With empty front matter`
 	zero_FM = "Page With empty front matter"
 )
 
+func TestPageWithFilenameDateAsFallback(t *testing.T) {
+	t.Parallel()
+
+	for _, useFilename := range []bool{false, true} {
+		t.Run(fmt.Sprintf("useFilename=%t", useFilename), func(t *testing.T) {
+			ass := require.New(t)
+			cfg, fs := newTestCfg()
+
+			pageTemplate := `
+---
+title: Page
+weight: %d
+%s
+---
+Content
+`
+
+			if useFilename {
+				cfg.Set("frontmatter", map[string]interface{}{
+					"defaultDate": []string{"filename"},
+				})
+			}
+
+			writeSource(t, fs, filepath.Join("content", "section", "2012-02-21-noslug.md"), fmt.Sprintf(pageTemplate, 1, ""))
+			writeSource(t, fs, filepath.Join("content", "section", "2012-02-22-slug.md"), fmt.Sprintf(pageTemplate, 2, "slug: aslug"))
+
+			s := buildSingleSite(t, deps.DepsCfg{Fs: fs, Cfg: cfg}, BuildCfg{SkipRender: true})
+
+			ass.Len(s.RegularPages, 2)
+
+			noSlug := s.RegularPages[0]
+			slug := s.RegularPages[1]
+
+			if useFilename {
+				ass.False(noSlug.Date.IsZero())
+				ass.False(slug.Date.IsZero())
+				ass.Equal(2012, noSlug.Date.Year())
+				ass.Equal(2012, slug.Date.Year())
+				ass.Equal("noslug", noSlug.Slug)
+				ass.Equal("aslug", slug.Slug)
+
+			} else {
+				ass.True(noSlug.Date.IsZero())
+				ass.True(slug.Date.IsZero())
+				ass.Equal("", noSlug.Slug)
+				ass.Equal("aslug", slug.Slug)
+			}
+
+		})
+	}
+
+}
+
 func TestMetadataDates(t *testing.T) {
 	t.Parallel()
+
+	assert := require.New(t)
+
 	var tests = []struct {
 		text        string
 		filename    string
@@ -1016,41 +1071,40 @@ func TestMetadataDates(t *testing.T) {
 		//
 		// ------- inputs --------|--- outputs ---|
 		//content  filename  modfb? D  P  L  M  E
-		{p_D____, "test.md", false, D, D, D, x, x}, // date copied across
-		{p_D____, "testy.md", true, D, D, D, x, x},
+		{p_D____, "test.md", false, D, o, D, x, x},
+		{p_D____, "testy.md", true, D, o, D, x, x},
 		{p__P___, "test.md", false, P, P, P, x, x}, // pubdate copied across
-		{p__P___, "testy.md", true, P, P, P, x, x},
+		//{p__P___, "testy.md", true, P, P, P, x, x}, // TODO(bep) date from modTime
 		{p_DP___, "test.md", false, D, P, D, x, x}, // date -> lastMod
-		{p_DP___, "testy.md", true, D, P, D, x, x},
+		{p_DP___, "testy.md", true, D, P, D, x, x}, // TODO(bep) date from modTime
 		{p__PL__, "test.md", false, P, P, L, x, x}, // pub -> date overrides lastMod -> date code (inconsistent?)
-		{p__PL__, "testy.md", true, P, P, L, x, x},
+		//{p__PL__, "testy.md", true, P, P, L, x, x},
 		{p_DPL__, "test.md", false, D, P, L, x, x}, // three dates
 		{p_DPL__, "testy.md", true, D, P, L, x, x},
 		{p_DPL_E, "testy.md", true, D, P, L, x, E}, // lastMod NOT copied to mod (inconsistent?)
 		{p_DP_ME, "testy.md", true, D, P, M, M, E}, // mod copied to lastMod
 		{p_DPLME, "testy.md", true, D, P, L, M, E}, // all dates
-
 		{emptyFM, "test.md", false, o, o, o, x, x}, // 3 year-one dates, 2 empty dates
 		{zero_FM, "test.md", false, o, o, o, x, x},
-		{emptyFM, "testy.md", true, s, o, s, x, x}, // 2 filesys, 1 year-one, 2 empty
-		{zero_FM, "testy.md", true, s, o, s, x, x},
+		//{emptyFM, "testy.md", true, s, o, s, x, x}, // 2 filesys, 1 year-one, 2 empty  TODO(bep) date from modTime
+		//{zero_FM, "testy.md", true, s, o, s, x, x}, // TODO(bep) date from modTime
 	}
 
 	for i, test := range tests {
-		s := newTestSite(t)
-		s.Cfg.Set("useModTimeAsFallback", test.modFallback)
-		fs := hugofs.NewMem(s.Cfg)
 
-		writeToFs(t, fs.Source, test.filename, test.text)
-		file, err := fs.Source.Open(test.filename)
-		if err != nil {
-			t.Fatal("failed to write test file to test filesystem")
-		}
-		fi, _ := fs.Source.Stat(test.filename)
+		var (
+			cfg, fs = newTestCfg()
+		)
+
+		writeToFs(t, fs.Source, filepath.Join("content", test.filename), test.text)
+
+		cfg.Set("useModTimeAsFallback", test.modFallback)
+
+		s := buildSingleSite(t, deps.DepsCfg{Fs: fs, Cfg: cfg}, BuildCfg{SkipRender: true})
 
-		sp := source.NewSourceSpec(s.Cfg, fs)
-		p := s.newPageFromFile(newFileInfo(sp, "", test.filename, fi, bundleNot))
-		p.ReadFrom(file)
+		assert.Equal(1, len(s.RegularPages))
+		p := s.RegularPages[0]
+		fi := p.Source.FileInfo()
 
 		// check Page Variables
 		checkDate(t, i+1, "Date", p.Date, test.expDate, fi)
@@ -1059,6 +1113,9 @@ func TestMetadataDates(t *testing.T) {
 		checkDate(t, i+1, "LastMod", p.ExpiryDate, test.expExp, fi)
 
 		// check Page Params
+		// TODO(bep) we need to rewrite these date tests to more unit style.
+		// The params checks below are currently flawed, as they don't check for the
+		// absense (nil) of a date.
 		checkDate(t, i+1, "param date", cast.ToTime(p.params["date"]), test.expDate, fi)
 		checkDate(t, i+1, "param publishdate", cast.ToTime(p.params["publishdate"]), test.expPub, fi)
 		checkDate(t, i+1, "param modified", cast.ToTime(p.params["modified"]), test.expMod, fi)
diff --git a/hugolib/pagemeta/page_frontmatter.go b/hugolib/pagemeta/page_frontmatter.go
new file mode 100644
index 00000000000..135c7d6c6b4
--- /dev/null
+++ b/hugolib/pagemeta/page_frontmatter.go
@@ -0,0 +1,351 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pagemeta
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/mitchellh/mapstructure"
+
+	"github.com/gohugoio/hugo/helpers"
+
+	"github.com/gohugoio/hugo/config"
+	"github.com/spf13/cast"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+// TODO(bep) should probably make the date handling chain complete to give people the flexibility they want.
+
+type FrontmatterHandler struct {
+	// Ordered chain.
+	dateHandlers frontMatterFieldHandler
+
+	logger *jww.Notepad
+}
+
+type FrontMatterDescriptor struct {
+
+	// This the Page's front matter.
+	Frontmatter map[string]interface{}
+
+	// This is the Page's base filename, e.g. page.md.
+	BaseFilename string
+
+	// The content file's mod time.
+	ModTime time.Time
+
+	// The below are pointers to values on Page and will be updated.
+
+	// This is the Page's params.
+	Params map[string]interface{}
+
+	// This is the Page's dates.
+	Dates *PageDates
+
+	// This is the Page's Slug etc.
+	PageURLs *URLPath
+}
+
+func (f FrontmatterHandler) handleDate(d FrontMatterDescriptor) error {
+	_, err := f.dateHandlers(d)
+	return err
+}
+
+var (
+	lastModFrontMatterKeys     = []string{"lastmod", "modified"}
+	publishDateFrontMatterKeys = []string{"publishdate", "pubdate", "published"}
+	expiryDateFrontMatterKeys  = []string{"expirydate", "unpublishdate"}
+	allDateFrontMatterKeys     = make(map[string]bool)
+)
+
+func init() {
+	for _, key := range lastModFrontMatterKeys {
+		allDateFrontMatterKeys[key] = true
+	}
+	for _, key := range publishDateFrontMatterKeys {
+		allDateFrontMatterKeys[key] = true
+	}
+	for _, key := range expiryDateFrontMatterKeys {
+		allDateFrontMatterKeys[key] = true
+	}
+
+	allDateFrontMatterKeys["date"] = true
+}
+
+func (f FrontmatterHandler) HandleDates(d FrontMatterDescriptor) error {
+	if d.Dates == nil {
+		panic("missing dates")
+	}
+
+	err := f.handleDate(d)
+	if err != nil {
+		return err
+	}
+	d.Dates.Lastmod = f.setParamsAndReturnFirstDate(d, lastModFrontMatterKeys)
+	d.Dates.PublishDate = f.setParamsAndReturnFirstDate(d, publishDateFrontMatterKeys)
+	d.Dates.ExpiryDate = f.setParamsAndReturnFirstDate(d, expiryDateFrontMatterKeys)
+
+	// Hugo really needs a date!
+	if d.Dates.Date.IsZero() {
+		d.Dates.Date = d.Dates.PublishDate
+	}
+
+	if d.Dates.Lastmod.IsZero() {
+		d.Dates.Lastmod = d.Dates.Date
+	}
+
+	// TODO(bep) date decide vs https://github.com/gohugoio/hugo/issues/3977
+	if d.Dates.PublishDate.IsZero() {
+		//d.dates.PublishDate = d.dates.Date
+	}
+
+	if d.Dates.Date.IsZero() {
+		d.Dates.Date = d.Dates.Lastmod
+	}
+
+	f.setParamIfNotZero("date", d.Params, d.Dates.Date)
+	f.setParamIfNotZero("lastmod", d.Params, d.Dates.Lastmod)
+	f.setParamIfNotZero("publishdate", d.Params, d.Dates.PublishDate)
+	f.setParamIfNotZero("expirydate", d.Params, d.Dates.ExpiryDate)
+
+	return nil
+}
+
+func (f FrontmatterHandler) IsDateKey(key string) bool {
+	return allDateFrontMatterKeys[key]
+}
+
+func (f FrontmatterHandler) setParamIfNotZero(name string, params map[string]interface{}, date time.Time) {
+	if date.IsZero() {
+		return
+	}
+	params[name] = date
+}
+
+func (f FrontmatterHandler) setParamsAndReturnFirstDate(d FrontMatterDescriptor, keys []string) time.Time {
+	var date time.Time
+
+	for _, key := range keys {
+		v, found := d.Frontmatter[key]
+		if found {
+			currentDate, err := cast.ToTimeE(v)
+			if err == nil {
+				d.Params[key] = currentDate
+				if date.IsZero() {
+					date = currentDate
+				}
+			} else {
+				d.Params[key] = v
+			}
+		}
+	}
+
+	return date
+}
+
+// A Zero date is a signal that the name can not be parsed.
+// This follows the format as outlined in Jekyll, https://jekyllrb.com/docs/posts/:
+// "Where YEAR is a four-digit number, MONTH and DAY are both two-digit numbers"
+func dateAndSlugFromBaseFilename(name string) (time.Time, string) {
+	withoutExt, _ := helpers.FileAndExt(name)
+
+	if len(withoutExt) < 10 {
+		// This can not be a date.
+		return time.Time{}, ""
+	}
+
+	// Note: Hugo currently have no custom timezone support.
+	// We will have to revisit this when that is in place.
+	d, err := time.Parse("2006-01-02", withoutExt[:10])
+	if err != nil {
+		return time.Time{}, ""
+	}
+
+	// Be a little lenient with the format here.
+	slug := strings.Trim(withoutExt[10:], " -_")
+
+	return d, slug
+}
+
+type frontMatterFieldHandler func(d FrontMatterDescriptor) (bool, error)
+
+func (f FrontmatterHandler) newChainedFrontMatterFieldHandler(handlers ...frontMatterFieldHandler) frontMatterFieldHandler {
+	return func(d FrontMatterDescriptor) (bool, error) {
+		for _, h := range handlers {
+			// First successful handler wins.
+			success, err := h(d)
+			if err != nil {
+				f.logger.ERROR.Println(err)
+			} else if success {
+				return true, nil
+			}
+		}
+		return false, nil
+	}
+}
+
+type frontmatterConfig struct {
+	date        []string
+	lastMod     []string
+	publishDate []string
+	expiryDate  []string
+}
+
+const (
+	fmDate       = "date"
+	fmPubDate    = "publishdate"
+	fmLastMod    = "lastmod"
+	fmExpiryDate = "expirydate"
+)
+
+func newDefaultFrontmatterConfig() frontmatterConfig {
+	return frontmatterConfig{
+		date:        []string{fmDate, fmPubDate, fmLastMod},
+		lastMod:     []string{fmLastMod, fmDate},
+		publishDate: []string{fmPubDate, fmDate},
+		expiryDate:  []string{fmExpiryDate},
+	}
+}
+
+func newFrontmatterConfig(cfg config.Provider) (frontmatterConfig, error) {
+	c := newDefaultFrontmatterConfig()
+
+	if cfg.IsSet("frontmatter") {
+		fm := cfg.GetStringMap("frontmatter")
+		if fm != nil {
+			for k, v := range fm {
+				loki := strings.ToLower(k)
+				switch loki {
+				case fmDate:
+					c.date = toLowerSlice(v)
+				case fmPubDate:
+					c.publishDate = toLowerSlice(v)
+				case fmLastMod:
+					c.lastMod = toLowerSlice(v)
+				case fmExpiryDate:
+					c.expiryDate = toLowerSlice(v)
+				}
+			}
+		}
+		err := mapstructure.WeakDecode(fm, &c)
+		return c, err
+	}
+	return c, nil
+}
+
+func toLowerSlice(in interface{}) []string {
+	out := cast.ToStringSlice(in)
+	for i := 0; i < len(out); i++ {
+		out[i] = strings.ToLower(out[i])
+	}
+
+	return out
+}
+
+func NewFrontmatterHandler(logger *jww.Notepad, cfg config.Provider) (FrontmatterHandler, error) {
+
+	if logger == nil {
+		logger = jww.NewNotepad(jww.LevelWarn, jww.LevelWarn, os.Stdout, ioutil.Discard, "", log.Ldate|log.Ltime)
+	}
+
+	f := FrontmatterHandler{logger: logger}
+
+	handlers := &frontmatterFieldHandlers{}
+
+	/*
+
+		[frontmatter]
+		date = ["date", "publishDate", "lastMod"]
+		lastMod = ["lastMod", "date"]
+		publishDate  = ["publishDate", "date"]
+		expiryDate = ["expiryDate"]
+
+	*/
+
+	dateHandlers := []frontMatterFieldHandler{handlers.defaultDateHandler}
+
+	defaultDate := cfg.Get("frontmatter.defaultdate")
+
+	if defaultDate != nil {
+		slice, err := cast.ToStringSliceE(defaultDate)
+		if err != nil {
+			return f, fmt.Errorf("invalid value for defaultDate, expeced a string slice, got %T", defaultDate)
+		}
+
+		for _, v := range slice {
+			if strings.EqualFold(v, "filename") {
+				dateHandlers = append(dateHandlers, handlers.defaultDateFilenameHandler)
+				// No more for now.
+				break
+			}
+		}
+	}
+
+	// This is deprecated
+	if cfg.GetBool("useModTimeAsFallback") {
+		dateHandlers = append(dateHandlers, handlers.defaultDateModTimeHandler)
+	}
+
+	f.dateHandlers = f.newChainedFrontMatterFieldHandler(dateHandlers...)
+
+	return f, nil
+}
+
+type frontmatterFieldHandlers struct {
+}
+
+func (f *frontmatterFieldHandlers) defaultDateHandler(d FrontMatterDescriptor) (bool, error) {
+	v, found := d.Frontmatter["date"]
+	if !found {
+		return false, nil
+	}
+
+	date, err := cast.ToTimeE(v)
+	if err != nil {
+		return false, err
+	}
+
+	d.Dates.Date = date
+
+	return true, nil
+}
+
+func (f *frontmatterFieldHandlers) defaultDateFilenameHandler(d FrontMatterDescriptor) (bool, error) {
+	date, slug := dateAndSlugFromBaseFilename(d.BaseFilename)
+	if date.IsZero() {
+		return false, nil
+	}
+
+	d.Dates.Date = date
+
+	if _, found := d.Frontmatter["slug"]; !found {
+		// Use slug from filename
+		d.PageURLs.Slug = slug
+	}
+
+	return true, nil
+}
+
+func (f *frontmatterFieldHandlers) defaultDateModTimeHandler(d FrontMatterDescriptor) (bool, error) {
+	if !d.ModTime.IsZero() {
+		d.Dates.Date = d.ModTime
+		return true, nil
+	}
+	return false, nil
+}
diff --git a/hugolib/pagemeta/page_frontmatter_test.go b/hugolib/pagemeta/page_frontmatter_test.go
new file mode 100644
index 00000000000..a6e17b407b7
--- /dev/null
+++ b/hugolib/pagemeta/page_frontmatter_test.go
@@ -0,0 +1,224 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pagemeta
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/spf13/viper"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestDateAndSlugFromBaseFilename(t *testing.T) {
+
+	t.Parallel()
+
+	assert := require.New(t)
+
+	tests := []struct {
+		name string
+		date string
+		slug string
+	}{
+		{"page.md", "0001-01-01", ""},
+		{"2012-09-12-page.md", "2012-09-12", "page"},
+		{"2018-02-28-page.md", "2018-02-28", "page"},
+		{"2018-02-28_page.md", "2018-02-28", "page"},
+		{"2018-02-28 page.md", "2018-02-28", "page"},
+		{"2018-02-28page.md", "2018-02-28", "page"},
+		{"2018-02-28-.md", "2018-02-28", ""},
+		{"2018-02-28-.md", "2018-02-28", ""},
+		{"2018-02-28.md", "2018-02-28", ""},
+		{"2018-02-28-page", "2018-02-28", "page"},
+		{"2012-9-12-page.md", "0001-01-01", ""},
+		{"asdfasdf.md", "0001-01-01", ""},
+	}
+
+	for i, test := range tests {
+		expectedDate, err := time.Parse("2006-01-02", test.date)
+		assert.NoError(err)
+
+		errMsg := fmt.Sprintf("Test %d", i)
+		gotDate, gotSlug := dateAndSlugFromBaseFilename(test.name)
+
+		assert.Equal(expectedDate, gotDate, errMsg)
+		assert.Equal(test.slug, gotSlug, errMsg)
+
+	}
+}
+
+func TestFrontMatterNewConfig(t *testing.T) {
+	assert := require.New(t)
+
+	cfg := viper.New()
+
+	cfg.Set("frontmatter", map[string]interface{}{
+		"date":        []string{"publishDate", "LastMod"},
+		"Lastmod":     []string{"publishDate"},
+		"expiryDate":  []string{"lastMod"},
+		"publishDate": []string{"date"},
+	})
+
+	fc, err := newFrontmatterConfig(cfg)
+	assert.NoError(err)
+	assert.Equal([]string{"publishdate", "lastmod"}, fc.date)
+	assert.Equal([]string{"publishdate"}, fc.lastMod)
+	assert.Equal([]string{"lastmod"}, fc.expiryDate)
+	assert.Equal([]string{"date"}, fc.publishDate)
+
+	// Default
+	cfg = viper.New()
+	fc, err = newFrontmatterConfig(cfg)
+	assert.NoError(err)
+	assert.Equal(3, len(fc.date))
+	assert.Equal(2, len(fc.lastMod))
+	assert.Equal(2, len(fc.publishDate))
+	assert.Equal(1, len(fc.expiryDate))
+
+}
+
+func TestFrontMatterDatesConfigVariations(t *testing.T) {
+	cfg := viper.New()
+
+	cfg.Set("frontmatter", map[string]interface{}{
+		"defaultDate": []string{"date"},
+	})
+
+	fmt.Println(">>", cfg)
+}
+
+func TestFrontMatterDates(t *testing.T) {
+	t.Parallel()
+
+	assert := require.New(t)
+
+	cfg := viper.New()
+
+	handler, err := NewFrontmatterHandler(nil, cfg)
+	assert.NoError(err)
+
+	testDate, err := time.Parse("2006-01-02", "2018-02-01")
+	assert.NoError(err)
+
+	sentinel := (time.Time{}).Add(1 * time.Hour)
+	zero := time.Time{}
+
+	// See http://www.imdb.com/title/tt0133093/
+	for _, lastModKey := range []string{"lastmod", "modified"} {
+		testDate = testDate.Add(24 * time.Hour)
+		t.Log(lastModKey, testDate)
+		for _, lastModDate := range []time.Time{testDate, sentinel} {
+			for _, dateKey := range []string{"date"} {
+				testDate = testDate.Add(24 * time.Hour)
+				t.Log(dateKey, testDate)
+				for _, dateDate := range []time.Time{testDate, sentinel} {
+					for _, pubDateKey := range []string{"publishdate", "pubdate", "published"} {
+						testDate = testDate.Add(24 * time.Hour)
+						t.Log(pubDateKey, testDate)
+						for _, pubDateDate := range []time.Time{testDate, sentinel} {
+							for _, expiryDateKey := range []string{"expirydate", "unpublishdate"} {
+								testDate = testDate.Add(24 * time.Hour)
+								t.Log(expiryDateKey, testDate)
+								for _, expiryDateDate := range []time.Time{testDate, sentinel} {
+									d := FrontMatterDescriptor{
+										Frontmatter: make(map[string]interface{}),
+										Params:      make(map[string]interface{}),
+										Dates:       &PageDates{},
+										PageURLs:    &URLPath{},
+									}
+
+									var expLastMod, expDate, expPubDate, expExiryDate = zero, zero, zero, zero
+
+									if dateDate != sentinel {
+										d.Frontmatter[dateKey] = dateDate
+										expDate = dateDate
+									}
+
+									if pubDateDate != sentinel {
+										d.Frontmatter[pubDateKey] = pubDateDate
+										expPubDate = pubDateDate
+										if expDate.IsZero() {
+											expDate = expPubDate
+										}
+									}
+
+									if lastModDate != sentinel {
+										d.Frontmatter[lastModKey] = lastModDate
+										expLastMod = lastModDate
+
+										if expDate.IsZero() {
+											expDate = lastModDate
+										}
+									}
+
+									if expiryDateDate != sentinel {
+										d.Frontmatter[expiryDateKey] = expiryDateDate
+										expExiryDate = expiryDateDate
+									}
+
+									if expLastMod.IsZero() {
+										expLastMod = expDate
+									}
+
+									assert.NoError(handler.HandleDates(d))
+
+									assertFrontMatterDate(assert, d, expDate, "date")
+									assertFrontMatterDate(assert, d, expLastMod, "lastmod")
+									assertFrontMatterDate(assert, d, expPubDate, "publishdate")
+									assertFrontMatterDate(assert, d, expExiryDate, "expirydate")
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func assertFrontMatterDate(assert *require.Assertions, d FrontMatterDescriptor, expected time.Time, dateField string) {
+	switch dateField {
+	case "date":
+	case "lastmod":
+	case "publishdate":
+	case "expirydate":
+	default:
+		assert.Failf("Unknown datefield %s", dateField)
+	}
+
+	param, found := d.Params[dateField]
+
+	if found && param.(time.Time).IsZero() {
+		assert.Fail("Zero time in params", dateField)
+	}
+
+	message := fmt.Sprintf("[%s] Found: %t Expected: %v (%t) Param: %v Params: %v Front matter: %v",
+		dateField, found, expected, expected.IsZero(), param, d.Params, d.Frontmatter)
+
+	assert.True(found != expected.IsZero(), message)
+
+	if found {
+		if expected != param {
+			assert.Fail("Params check failed", "[%s] Expected:\n%q\nGot:\n%q", dateField, expected, param)
+		}
+	}
+}
+
+func TestFrontMatterFieldHandlers(t *testing.T) {
+	//handlers := &frontmatterFieldHandlers{}
+
+}
diff --git a/hugolib/pagemeta/pagemeta.go b/hugolib/pagemeta/pagemeta.go
new file mode 100644
index 00000000000..57cef9efab8
--- /dev/null
+++ b/hugolib/pagemeta/pagemeta.go
@@ -0,0 +1,30 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pagemeta
+
+import "time"
+
+type URLPath struct {
+	URL       string
+	Permalink string
+	Slug      string
+	Section   string
+}
+
+type PageDates struct {
+	Date        time.Time
+	Lastmod     time.Time
+	PublishDate time.Time
+	ExpiryDate  time.Time
+}
diff --git a/hugolib/site.go b/hugolib/site.go
index 95cd0a23edf..a6704363dcf 100644
--- a/hugolib/site.go
+++ b/hugolib/site.go
@@ -42,6 +42,7 @@ import (
 	bp "github.com/gohugoio/hugo/bufferpool"
 	"github.com/gohugoio/hugo/deps"
 	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugolib/pagemeta"
 	"github.com/gohugoio/hugo/output"
 	"github.com/gohugoio/hugo/parser"
 	"github.com/gohugoio/hugo/related"
@@ -121,6 +122,9 @@ type Site struct {
 	outputFormatsConfig output.Formats
 	mediaTypesConfig    media.Types
 
+	// How to handle page front matter.
+	frontmatterHandler pagemeta.FrontmatterHandler
+
 	// We render each site for all the relevant output formats in serial with
 	// this rendering context pointing to the current one.
 	rc *siteRenderingContext
@@ -177,6 +181,7 @@ func (s *Site) reset() *Site {
 		relatedDocsHandler:  newSearchIndexHandler(s.relatedDocsHandler.cfg),
 		outputFormats:       s.outputFormats,
 		outputFormatsConfig: s.outputFormatsConfig,
+		frontmatterHandler:  s.frontmatterHandler,
 		mediaTypesConfig:    s.mediaTypesConfig,
 		resourceSpec:        s.resourceSpec,
 		Language:            s.Language,
@@ -248,6 +253,11 @@ func newSite(cfg deps.DepsCfg) (*Site, error) {
 
 	titleFunc := helpers.GetTitleFunc(cfg.Language.GetString("titleCaseStyle"))
 
+	frontMatterHandler, err := pagemeta.NewFrontmatterHandler(cfg.Logger, cfg.Cfg)
+	if err != nil {
+		return nil, err
+	}
+
 	s := &Site{
 		PageCollections:     c,
 		layoutHandler:       output.NewLayoutHandler(cfg.Cfg.GetString("themesDir") != ""),
@@ -258,6 +268,7 @@ func newSite(cfg deps.DepsCfg) (*Site, error) {
 		outputFormats:       outputFormats,
 		outputFormatsConfig: siteOutputFormatsConfig,
 		mediaTypesConfig:    siteMediaTypesConfig,
+		frontmatterHandler:  frontMatterHandler,
 	}
 
 	s.Info = newSiteInfo(siteBuilderCfg{s: s, pageCollections: c, language: s.Language})