diff --git a/go.mod b/go.mod
index 7821424..7a91a22 100644
--- a/go.mod
+++ b/go.mod
@@ -18,6 +18,7 @@ require (
 	github.com/go-chi/render v1.0.1
 	github.com/go-git/go-git/v5 v5.2.0
 	github.com/google/gofuzz v1.2.0 // indirect
+	github.com/google/uuid v1.1.2
 	github.com/gorilla/mux v1.8.0 // indirect
 	github.com/morikuni/aec v1.0.0 // indirect
 	github.com/opencontainers/go-digest v1.0.0 // indirect
diff --git a/go.sum b/go.sum
index 06f6ea0..8fc3717 100644
--- a/go.sum
+++ b/go.sum
@@ -162,6 +162,7 @@ github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OI
 github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
 github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
 github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.1.2 h1:EVhdT+1Kseyi1/pUmXKaFxYsDNy9RQYkMWRH68J/W7Y=
 github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
 github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
diff --git a/pkg/models/models.go b/pkg/models/models.go
index cfbf0b4..741bb82 100644
--- a/pkg/models/models.go
+++ b/pkg/models/models.go
@@ -3,6 +3,7 @@ package models
 import (
 	"errors"
 	"github.com/go-git/go-git/v5/plumbing"
+	log "github.com/sirupsen/logrus"
 	"net/http"
 	"time"
 )
@@ -69,3 +70,57 @@ func (u *User) Bind(*http.Request) error {
 
 	return nil
 }
+
+type Job struct {
+	PackageName string
+	Status      BuildStatus
+	Logs        BuildLog `json:",omitempty"`
+	Uuid        string
+	Time        time.Time
+}
+
+// logsToKeep are the number of log lines to keep when sending a job.
+const logsToKeep = 10
+
+func (j Job) Render(w http.ResponseWriter, r *http.Request) error {
+	// Remove everything but the last 10 log lines. To get all
+	// logs the /job/{uuid}/logs route can be used. This is because
+	// the logs can get quite large, and if you want information about a single
+	// job it's not really useful to get all the logs. This is especially true
+	// when retrieving *all* jobs. In that case you really don't want all logs to
+	// be sent over as well
+	if len(j.Logs) > logsToKeep {
+		j.Logs = j.Logs[len(j.Logs)-logsToKeep:]
+	}
+
+	return nil
+}
+
+type BuildStatus int
+
+const (
+	BuildStatusPending BuildStatus = iota
+	BuildStatusPullingRepo
+	BuildStatusRunning
+	BuildStatusUploading
+	BuildStatusDone
+
+	BuildStatusErrored
+)
+
+type LogLine struct {
+	Time    time.Time
+	Level   log.Level
+	message string
+}
+
+func (j LogLine) Bind(r *http.Request) error {
+	return nil
+}
+
+type BuildLog []LogLine
+
+func (j LogLine) Render(w http.ResponseWriter, r *http.Request) error {
+
+	return nil
+}
diff --git a/pkg/store/jobstore.go b/pkg/store/jobstore.go
new file mode 100644
index 0000000..242abca
--- /dev/null
+++ b/pkg/store/jobstore.go
@@ -0,0 +1,217 @@
+package store
+
+import (
+	"bytes"
+	"encoding/gob"
+	"github.com/dgraph-io/badger/v2"
+	"github.com/finitum/AAAAA/pkg/models"
+	"github.com/google/uuid"
+	"github.com/pkg/errors"
+	"sync"
+	"time"
+)
+
+type JobStoreWrapper struct {
+	*Badger
+
+	sync.Mutex
+	callbacks map[string][]func(line *models.LogLine)
+}
+
+func NewJobStore(badger *Badger) JobStore {
+	return &JobStoreWrapper{
+		Badger:    badger,
+		callbacks: make(map[string][]func(line *models.LogLine)),
+	}
+}
+
+func (b *JobStoreWrapper) NewJob(name string) (*models.Job, error) {
+	jid, err := uuid.NewUUID()
+	if err != nil {
+		return nil, errors.Wrap(err, "uuid")
+	}
+
+	job := models.Job{
+		PackageName: name,
+		Status:      models.BuildStatusPending,
+		Logs:        nil,
+		Uuid:        jid.String(),
+		Time:        time.Now(),
+	}
+
+	err = b.db.Update(func(txn *badger.Txn) error {
+		var value bytes.Buffer
+
+		enc := gob.NewEncoder(&value)
+		err := enc.Encode(job)
+		if err != nil {
+			return errors.Wrap(err, "gob encode")
+		}
+
+		entry := badger.NewEntry([]byte(jobPrefix+jid.String()), value.Bytes()).WithTTL(jobTTL)
+		return errors.Wrap(txn.SetEntry(entry), "badger transaction")
+	})
+
+	return &job, err
+}
+
+func (b *JobStoreWrapper) AppendToJobLog(jid string, l *models.LogLine) error {
+	for _, cb := range b.callbacks[jid] {
+		cb(l)
+	}
+
+	return b.db.Update(func(txn *badger.Txn) error {
+		var job models.Job
+
+		// Get the job
+		item, err := txn.Get([]byte(jobPrefix + jid))
+		if err == badger.ErrKeyNotFound {
+			return ErrNotExists
+		} else if err != nil {
+			return errors.Wrap(err, "badger get")
+		}
+		err = item.Value(func(val []byte) error {
+			buf := bytes.NewBuffer(val)
+
+			dec := gob.NewDecoder(buf)
+			return errors.Wrap(dec.Decode(&job), "gob decode")
+		})
+		if err != nil {
+			return err
+		}
+
+		// Update the job
+		job.Logs = append(job.Logs, *l)
+
+		// Put the job back
+		var value bytes.Buffer
+		enc := gob.NewEncoder(&value)
+		err = enc.Encode(job)
+		if err != nil {
+			return errors.Wrap(err, "gob encode")
+		}
+
+		entry := badger.NewEntry([]byte(jobPrefix+jid), value.Bytes()).WithTTL(jobTTL)
+		return errors.Wrap(txn.SetEntry(entry), "badger transaction")
+	})
+}
+
+func (b *JobStoreWrapper) SetJobStatus(jid string, status models.BuildStatus) error {
+	return b.db.Update(func(txn *badger.Txn) error {
+		var job models.Job
+
+		// Get the job
+		item, err := txn.Get([]byte(jobPrefix + jid))
+		if err == badger.ErrKeyNotFound {
+			return ErrNotExists
+		} else if err != nil {
+			return errors.Wrap(err, "badger get")
+		}
+		err = item.Value(func(val []byte) error {
+			buf := bytes.NewBuffer(val)
+
+			dec := gob.NewDecoder(buf)
+			return errors.Wrap(dec.Decode(&job), "gob decode")
+		})
+		if err != nil {
+			return err
+		}
+
+		// Update the job
+		job.Status = status
+
+		// Put the job back
+		var value bytes.Buffer
+		enc := gob.NewEncoder(&value)
+		err = enc.Encode(job)
+		if err != nil {
+			return errors.Wrap(err, "gob encode")
+		}
+
+		entry := badger.NewEntry([]byte(jobPrefix+jid), value.Bytes()).WithTTL(jobTTL)
+		return errors.Wrap(txn.SetEntry(entry), "badger transaction")
+	})
+}
+
+func (b *JobStoreWrapper) GetLogs(jid string) (logs []models.LogLine, _ error) {
+	return logs, b.db.View(func(txn *badger.Txn) error {
+		var job models.Job
+
+		// Get the job
+		item, err := txn.Get([]byte(jobPrefix + jid))
+		if err == badger.ErrKeyNotFound {
+			return ErrNotExists
+		} else if err != nil {
+			return errors.Wrap(err, "badger get")
+		}
+		err = item.Value(func(val []byte) error {
+			buf := bytes.NewBuffer(val)
+
+			dec := gob.NewDecoder(buf)
+			return errors.Wrap(dec.Decode(&job), "gob decode")
+		})
+		if err != nil {
+			return err
+		}
+
+		logs = job.Logs
+
+		return nil
+	})
+}
+
+func (b *JobStoreWrapper) GetJobs() (jobs []models.Job, _ error) {
+	return jobs, b.db.View(func(txn *badger.Txn) error {
+		it := txn.NewIterator(badger.DefaultIteratorOptions)
+		defer it.Close()
+		prefix := []byte(jobPrefix)
+		for it.Seek(prefix); it.ValidForPrefix(prefix); it.Next() {
+			item := it.Item()
+			var job models.Job
+			err := item.Value(func(val []byte) error {
+				buf := bytes.NewBuffer(val)
+
+				dec := gob.NewDecoder(buf)
+				return errors.Wrap(dec.Decode(&job), "gob decode")
+			})
+			jobs = append(jobs, job)
+			if err != nil {
+				return errors.Wrap(err, "badger iteration")
+			}
+		}
+		return nil
+	})
+}
+
+func (b *JobStoreWrapper) AddLogListener(uuid string, cb func(line *models.LogLine)) {
+	b.Lock()
+	defer b.Unlock()
+
+	b.callbacks[uuid] = append(b.callbacks[uuid], cb)
+}
+
+func (b *JobStoreWrapper) GetJob(jid string) (*models.Job, error) {
+	var job models.Job
+
+	return &job, b.db.View(func(txn *badger.Txn) error {
+
+		// Get the job
+		item, err := txn.Get([]byte(jobPrefix + jid))
+		if err == badger.ErrKeyNotFound {
+			return ErrNotExists
+		} else if err != nil {
+			return errors.Wrap(err, "badger get")
+		}
+		err = item.Value(func(val []byte) error {
+			buf := bytes.NewBuffer(val)
+
+			dec := gob.NewDecoder(buf)
+			return errors.Wrap(dec.Decode(&job), "gob decode")
+		})
+		if err != nil {
+			return err
+		}
+
+		return nil
+	})
+}
diff --git a/pkg/store/store.go b/pkg/store/store.go
index 14f31b5..b601e95 100644
--- a/pkg/store/store.go
+++ b/pkg/store/store.go
@@ -18,6 +18,7 @@ type Store interface {
 }
 
 const pkgPrefix = "pkg_"
+
 type PackageStore interface {
 	// GetPackage gets a package definition from the store MUST return ErrNotExists if the package does not exist
 	GetPackage(name string) (*models.Pkg, error)
@@ -32,6 +33,7 @@ type PackageStore interface {
 }
 
 const userPrefix = "user_"
+
 type UserStore interface {
 	// GetUser gets a user from the store MUST return ErrNotExists if the user does not exist
 	GetUser(name string) (*models.User, error)
@@ -88,3 +90,33 @@ func GetPartialCacheEntry(cache Cache, term string) (aur.Results, bool, error) {
 
 	return nil, false, ErrNotExists
 }
+
+const jobPrefix = "job_"
+
+// Keep job logs for 10 days
+const jobTTL = 10 * 24 * time.Hour
+
+type JobStore interface {
+	// NewJob creates a new job. It returns the newly created job, with in it the
+	// uuid of the job which can be used for further lookup.
+	NewJob(name string) (*models.Job, error)
+
+	// AppendToJobLog appends a line to a job's log
+	AppendToJobLog(uuid string, l *models.LogLine) error
+
+	// SetJobStatus updates the status of this job
+	SetJobStatus(uuid string, status models.BuildStatus) error
+
+	// GetLogs returns the entire log of this job
+	GetLogs(uuid string) ([]models.LogLine, error)
+
+	// GetJobs returns all jobs
+	GetJobs() ([]models.Job, error)
+
+	// AddLogListener takes a function which will be called every time a new logline is
+	// added the job targeted with the uuid
+	AddLogListener(uuid string, cb func(line *models.LogLine))
+
+	// GetJob gets a job by uuid
+	GetJob(uuid string) (*models.Job, error)
+}
diff --git a/services/buildlogs/filter.go b/services/buildlogs/filter.go
new file mode 100644
index 0000000..e5467c6
--- /dev/null
+++ b/services/buildlogs/filter.go
@@ -0,0 +1,84 @@
+package main
+
+import (
+	"github.com/finitum/AAAAA/pkg/models"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+// FilterJobs filters, sorts and paginates a list of jobs.
+//
+// * nameFilter is a keyword which if non-empty, must be included in the package name, or otherwise the job is filtered out.
+// * statusFilter is a keyword which if non-empty, filters out any job that doesn't have a build status equal to the number
+//   passed in. This parameter may start with a `!`, which negates the filter and filters out any job with a status equal to
+//   the number passed in.
+// * sortKey is the key in the remaining list of (filtered) jobs is sorted by before it's paginated. This parameter may
+//   be either `time` or `name`. If this parameter isn't `time` or `name` it will automatically be sorted by time.
+// * start and limit are used for pagination. Jobs returned are the filtered, sorted jobs sliced by [start:start+limit].
+//   limit may be -1 to signify no limit.
+func FilterJobs(jobs []models.Job, nameFilter, statusFilter, sortKey string, start, limit int) ([]models.Job, error) {
+	if statusFilter != "" {
+		reverse := false
+		if statusFilter[0] == '!' {
+			statusFilter = statusFilter[1:]
+			reverse = true
+		}
+
+		statusNumber, err := strconv.Atoi(statusFilter)
+		if err != nil {
+			return nil, err
+		}
+
+		fc := 0
+		for _, job := range jobs {
+			if (job.Status == models.BuildStatus(statusNumber) && !reverse) ||
+				(job.Status != models.BuildStatus(statusNumber) && reverse) {
+				jobs[fc] = job
+				fc++
+			}
+		}
+		jobs = jobs[:fc]
+	}
+
+	if nameFilter != "" {
+		fc := 0
+		for _, job := range jobs {
+			if strings.Contains(job.PackageName, nameFilter) {
+				jobs[fc] = job
+				fc++
+			}
+		}
+		jobs = jobs[:fc]
+	}
+
+	sort.Slice(jobs, func(i, j int) bool {
+		switch sortKey {
+		case "name":
+			name1 := jobs[i].PackageName
+			name2 := jobs[j].PackageName
+			return name1 < name2
+		case "time":
+			fallthrough
+		default:
+			return jobs[i].Time.After(jobs[j].Time)
+		}
+	})
+
+	if len(jobs) > start {
+		if limit == -1 {
+			jobs = jobs[start:]
+		} else {
+			end := start + limit
+			if end > len(jobs) {
+				end = len(jobs)
+			}
+
+			jobs = jobs[start:end]
+		}
+	} else {
+		jobs = []models.Job{}
+	}
+
+	return jobs, nil
+}
diff --git a/services/buildlogs/filter_test.go b/services/buildlogs/filter_test.go
new file mode 100644
index 0000000..ff9b585
--- /dev/null
+++ b/services/buildlogs/filter_test.go
@@ -0,0 +1,184 @@
+package main
+
+import (
+	"github.com/finitum/AAAAA/pkg/models"
+	"github.com/stretchr/testify/assert"
+	"testing"
+	"time"
+)
+
+var testJobList = []models.Job{
+	{
+		PackageName: "ccc",
+		Status:      0,
+		Logs:        nil,
+		Uuid:        "1",
+		Time:        time.Unix(10, 10),
+	},
+	{
+		PackageName: "aaa",
+		Status:      1,
+		Logs:        nil,
+		Uuid:        "2",
+		Time:        time.Unix(11, 10),
+	},
+	{
+		PackageName: "bbb",
+		Status:      0,
+		Logs:        nil,
+		Uuid:        "2",
+		Time:        time.Unix(12, 10),
+	},
+}
+
+func TestFilterLimitOne(t *testing.T) {
+	jobs := make([]models.Job, len(testJobList))
+	copy(jobs, testJobList)
+
+	// By defaul it sorts based on time. So it should return the latest time (bbb)
+	jobs, err := FilterJobs(jobs, "", "", "", 0, 1)
+	assert.NoError(t, err)
+	assert.Equal(t, len(jobs), 1)
+	assert.Equal(t, jobs[0].PackageName, "bbb")
+}
+
+func TestFilterLimitTwo(t *testing.T) {
+	jobs := make([]models.Job, len(testJobList))
+	copy(jobs, testJobList)
+
+	// By defaul it sorts based on time. So it should return the latest two times (bbb, aaa)
+	jobs, err := FilterJobs(jobs, "", "", "", 0, 2)
+	assert.NoError(t, err)
+	assert.Equal(t, len(jobs), 2)
+	assert.Equal(t, jobs[0].PackageName, "bbb")
+	assert.Equal(t, jobs[1].PackageName, "aaa")
+}
+
+func TestFilterLimitZero(t *testing.T) {
+	jobs := make([]models.Job, len(testJobList))
+	copy(jobs, testJobList)
+
+	// Limit 0 should return nothing
+	jobs, err := FilterJobs(jobs, "", "", "", 0, 0)
+	assert.NoError(t, err)
+	assert.Equal(t, len(jobs), 0)
+}
+
+func TestFilterStatusOne(t *testing.T) {
+	jobs := make([]models.Job, len(testJobList))
+	copy(jobs, testJobList)
+
+	// There's only one with status 1 (bbb)
+	jobs, err := FilterJobs(jobs, "", "1", "", 0, -1)
+	assert.NoError(t, err)
+	assert.Equal(t, len(jobs), 1)
+	assert.Equal(t, jobs[0].PackageName, "aaa")
+}
+
+func TestFilterStatusZero(t *testing.T) {
+	jobs := make([]models.Job, len(testJobList))
+	copy(jobs, testJobList)
+
+	// There are two  with status 0 (bbb and ccc) but ccc has the lowest time so should come last
+	jobs, err := FilterJobs(jobs, "", "0", "", 0, -1)
+	assert.NoError(t, err)
+	assert.Equal(t, len(jobs), 2)
+	assert.Equal(t, jobs[0].PackageName, "bbb")
+	assert.Equal(t, jobs[1].PackageName, "ccc")
+}
+
+func TestFilterStatusNotZero(t *testing.T) {
+	jobs := make([]models.Job, len(testJobList))
+	copy(jobs, testJobList)
+
+	// There are two with status 0 (bbb and ccc) so !0 should return a
+	jobs, err := FilterJobs(jobs, "", "!0", "", 0, -1)
+	assert.NoError(t, err)
+	assert.Equal(t, len(jobs), 1)
+	assert.Equal(t, jobs[0].PackageName, "aaa")
+}
+
+func TestFilterNameExact(t *testing.T) {
+	jobs := make([]models.Job, len(testJobList))
+	copy(jobs, testJobList)
+
+	// There are two with status 0 (bbb and ccc) so !0 should return a
+	jobs, err := FilterJobs(jobs, "aaa", "", "", 0, -1)
+	assert.NoError(t, err)
+	assert.Equal(t, len(jobs), 1)
+	assert.Equal(t, jobs[0].PackageName, "aaa")
+}
+
+func TestFilterNamePartial(t *testing.T) {
+	jobs := make([]models.Job, len(testJobList))
+	copy(jobs, testJobList)
+
+	// There are two with status 0 (bbb and ccc) so !0 should return a
+	jobs, err := FilterJobs(jobs, "a", "", "", 0, -1)
+	assert.NoError(t, err)
+	assert.Equal(t, len(jobs), 1)
+	assert.Equal(t, jobs[0].PackageName, "aaa")
+}
+
+func TestFilterSortTime(t *testing.T) {
+	jobs := make([]models.Job, len(testJobList))
+	copy(jobs, testJobList)
+
+	// Sort based on time explicitly
+	jobs, err := FilterJobs(jobs, "", "", "time", 0, -1)
+	assert.NoError(t, err)
+	assert.Equal(t, len(jobs), 3)
+	assert.Equal(t, jobs[0].PackageName, "bbb")
+	assert.Equal(t, jobs[1].PackageName, "aaa")
+	assert.Equal(t, jobs[2].PackageName, "ccc")
+}
+
+func TestFilterSortNothing(t *testing.T) {
+	jobs := make([]models.Job, len(testJobList))
+	copy(jobs, testJobList)
+
+	// Sorting on nothing also sorts on time by default
+	jobs, err := FilterJobs(jobs, "", "", "", 0, -1)
+	assert.NoError(t, err)
+	assert.Equal(t, len(jobs), 3)
+	assert.Equal(t, jobs[0].PackageName, "bbb")
+	assert.Equal(t, jobs[1].PackageName, "aaa")
+	assert.Equal(t, jobs[2].PackageName, "ccc")
+}
+
+func TestFilterSortName(t *testing.T) {
+	jobs := make([]models.Job, len(testJobList))
+	copy(jobs, testJobList)
+
+	jobs, err := FilterJobs(jobs, "", "", "name", 0, -1)
+	assert.NoError(t, err)
+	assert.Equal(t, len(jobs), 3)
+	assert.Equal(t, jobs[0].PackageName, "aaa")
+	assert.Equal(t, jobs[1].PackageName, "bbb")
+	assert.Equal(t, jobs[2].PackageName, "ccc")
+}
+
+func TestFilterStartZero(t *testing.T) {
+	jobs := make([]models.Job, len(testJobList))
+	copy(jobs, testJobList)
+
+	// Starting at zero is the default
+	jobs, err := FilterJobs(jobs, "", "", "name", 0, -1)
+	assert.NoError(t, err)
+	assert.Equal(t, len(jobs), 3)
+	assert.Equal(t, jobs[0].PackageName, "aaa")
+	assert.Equal(t, jobs[1].PackageName, "bbb")
+	assert.Equal(t, jobs[2].PackageName, "ccc")
+}
+
+func TestFilterStartOne(t *testing.T) {
+	jobs := make([]models.Job, len(testJobList))
+	copy(jobs, testJobList)
+
+	// Starting at zero is the default
+	jobs, err := FilterJobs(jobs, "", "", "name", 1, -1)
+	assert.NoError(t, err)
+	assert.Equal(t, len(jobs), 2)
+	assert.Equal(t, jobs[0].PackageName, "bbb")
+	assert.Equal(t, jobs[1].PackageName, "ccc")
+}
diff --git a/services/buildlogs/main.go b/services/buildlogs/main.go
new file mode 100644
index 0000000..7cb6751
--- /dev/null
+++ b/services/buildlogs/main.go
@@ -0,0 +1,46 @@
+package main
+
+import (
+	"context"
+	"github.com/finitum/AAAAA/internal/cors"
+	"github.com/finitum/AAAAA/pkg/store"
+	"github.com/go-chi/chi"
+	"github.com/go-chi/chi/middleware"
+	"github.com/go-chi/render"
+	log "github.com/sirupsen/logrus"
+	"net/http"
+	"os"
+)
+
+func init() {
+	log.SetLevel(log.TraceLevel)
+}
+
+func main() {
+	r := chi.NewRouter()
+	r.Use(middleware.StripSlashes)
+	r.Use(middleware.Logger)
+	r.Use(middleware.Recoverer)
+	r.Use(cors.AllowAll)
+	r.Use(render.SetContentType(render.ContentTypeJSON))
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	badger, err := store.OpenBadger(os.TempDir() + "/AAAAA-jobs")
+	if err != nil {
+		log.Fatalf("Couldn't open ristretto cache: %v", err)
+	}
+	defer badger.Close()
+	badger.StartGC(ctx)
+
+	js := store.NewJobStore(badger)
+	rs := NewRoutes(js)
+
+	r.Post("/job/{pkgname}", rs.NewJob)
+	r.Get("/job/{uuid}", rs.GetJob)
+	r.Get("/jobs", rs.GetJobs)
+	r.Get("/job/{uuid}/logs", rs.GetLogs)
+	r.Post("/job/{uuid}/logs", rs.AddLogs)
+
+	log.Fatal(http.ListenAndServe(":5002", r))
+}
diff --git a/services/buildlogs/routes.go b/services/buildlogs/routes.go
new file mode 100644
index 0000000..aff4cb2
--- /dev/null
+++ b/services/buildlogs/routes.go
@@ -0,0 +1,162 @@
+package main
+
+import (
+	"github.com/finitum/AAAAA/pkg/models"
+	"github.com/finitum/AAAAA/pkg/store"
+	"github.com/finitum/AAAAA/services/control_server/routes"
+	"github.com/go-chi/chi"
+	"github.com/go-chi/render"
+	log "github.com/sirupsen/logrus"
+	"net/http"
+	"strconv"
+)
+
+type Routes struct {
+	jobs store.JobStore
+}
+
+func NewRoutes(j store.JobStore) *Routes {
+	return &Routes{
+		j,
+	}
+}
+
+func (rs *Routes) NewJob(w http.ResponseWriter, r *http.Request) {
+	pkgname := chi.URLParam(r, "pkgname")
+
+	job, err := rs.jobs.NewJob(pkgname)
+	if err != nil {
+		_ = render.Render(w, r, routes.ErrServerError(err))
+		log.Errorf("failed to create new job (%v)", err)
+		return
+	}
+
+	_ = render.Render(w, r, job)
+	w.WriteHeader(http.StatusCreated)
+}
+
+func (rs *Routes) GetJob(w http.ResponseWriter, r *http.Request) {
+	uuid := chi.URLParam(r, "uuid")
+
+	job, err := rs.jobs.GetJob(uuid)
+	if err != nil {
+		_ = render.Render(w, r, routes.ErrServerError(err))
+		log.Errorf("failed to get job (%v)", err)
+		return
+	}
+
+	_ = render.Render(w, r, job)
+}
+
+func (rs *Routes) GetLogs(w http.ResponseWriter, r *http.Request) {
+	uuid := chi.URLParam(r, "uuid")
+
+	dbLogs, err := rs.jobs.GetLogs(uuid)
+	if err != nil {
+		_ = render.Render(w, r, routes.ErrServerError(err))
+		log.Errorf("failed to get logs (%v)", err)
+		return
+	}
+
+	logs := make([]render.Renderer, len(dbLogs))
+	for i, logLine := range logs {
+		logs[i] = logLine
+	}
+
+	_ = render.RenderList(w, r, logs)
+}
+
+// GetJobs possible routes:
+//	All jobs: /jobs
+// 	Get 10 jobs: /jobs?limit=10
+// 	Get jobs starting at job 10: /jobs?start=10
+// 	Get only the 10th job: /jobs?start=10&limit=1
+//
+// # Sorting is performed before filtering and limiting
+// 	Sort jobs by time: /jobs?sort=time
+// 	Sort jobs by package name: /jobs?sort=name
+//
+// # Filtering is performed before sorting
+//  Return only jobs with status 0 (pending) : /jobs?status=0
+//  Return only jobs with a status that's not 0 (pending) : /jobs?status=!0
+//  Return only jobs with `aaa` in the name: /jobs?name=aaa
+func (rs *Routes) GetJobs(w http.ResponseWriter, r *http.Request) {
+	limit := r.URL.Query().Get("limit")
+	start := r.URL.Query().Get("start")
+	sortKey := r.URL.Query().Get("sort")
+	statusFilter := r.URL.Query().Get("status")
+	nameFilter := r.URL.Query().Get("name")
+
+	var err error
+
+	startNum := 0
+	if start != "" {
+		startNum, err = strconv.Atoi(start)
+		if err != nil {
+			_ = render.Render(w, r, routes.ErrInvalidRequest(err))
+			log.Errorf("Couldn't convert status to number (%v)", err)
+			return
+		}
+		if startNum < 0 {
+			startNum = 0
+		}
+	}
+
+	limitNum := -1
+	if limit != "" {
+		limitNum, err = strconv.Atoi(limit)
+		if err != nil {
+			_ = render.Render(w, r, routes.ErrInvalidRequest(err))
+			log.Errorf("Couldn't convert status to number (%v)", err)
+			return
+		}
+		if limitNum < 0 {
+			limitNum = -1
+		}
+	}
+
+	// We will never return more than 5000 results
+	if limitNum > 5000 {
+		limitNum = 5000
+	}
+
+	dbJobs, err := rs.jobs.GetJobs()
+	if err != nil {
+		// TODO: maybe put these error functions in some kind of shared module (internal maybe?)
+		_ = render.Render(w, r, routes.ErrServerError(err))
+		log.Errorf("failed to get jobs (%v)", err)
+		return
+	}
+
+	dbJobs, err = FilterJobs(dbJobs, nameFilter, statusFilter, sortKey, startNum, limitNum)
+	if err != nil {
+		_ = render.Render(w, r, routes.ErrInvalidRequest(err))
+		log.Errorf("Couldn't convert status to number (%v)", err)
+		return
+	}
+
+	jobs := make([]render.Renderer, len(dbJobs))
+	for i, logLine := range dbJobs {
+		jobs[i] = logLine
+	}
+
+	_ = render.RenderList(w, r, jobs)
+}
+
+func (rs *Routes) AddLogs(w http.ResponseWriter, r *http.Request) {
+	uuid := chi.URLParam(r, "uuid")
+
+	var logLine models.LogLine
+
+	if err := render.Bind(r, &logLine); err != nil {
+		_ = render.Render(w, r, routes.ErrInvalidRequest(err))
+		return
+	}
+
+	err := rs.jobs.AppendToJobLog(uuid, &logLine)
+	if err != nil {
+		_ = render.Render(w, r, routes.ErrServerError(err))
+		log.Errorf("failed to add to logs (%v)", err)
+		return
+	}
+}
diff --git a/services/frontend/src/App.vue b/services/frontend/src/App.vue
index 5503ef3..44ad6bd 100644
--- a/services/frontend/src/App.vue
+++ b/services/frontend/src/App.vue
@@ -8,8 +8,8 @@
 <script lang="ts">
 import { defineComponent, ref } from "vue";
 import Header from "@/components/Header.vue";
-import Notification from "@/components/Notification.vue";
-import Login from "@/components/Login.vue";
+import Notification from "@/components/modals/Notification.vue";
+import Login from "@/components/modals/Login.vue";
 
 export default defineComponent({
   name: "App",
diff --git a/services/frontend/src/api/API.ts b/services/frontend/src/api/API.ts
index da70923..64a1daf 100644
--- a/services/frontend/src/api/API.ts
+++ b/services/frontend/src/api/API.ts
@@ -1,6 +1,6 @@
 import axios from "axios";
 import { Package, User } from "@/api/Models";
-import { notificationState } from "@/components/NotificationState";
+import { notificationState } from "@/components/modals/NotificationState";
 import { ref, watch } from "vue";
 
 const client = axios.create({
diff --git a/services/frontend/src/api/AUR.ts b/services/frontend/src/api/AUR.ts
index 49f9b44..e666079 100644
--- a/services/frontend/src/api/AUR.ts
+++ b/services/frontend/src/api/AUR.ts
@@ -1,5 +1,5 @@
 import axios from "axios";
-import { notificationState } from "@/components/NotificationState";
+import { notificationState } from "@/components/modals/NotificationState";
 import { NewPackage, Package } from "@/api/Models";
 
 export interface Result {
diff --git a/services/frontend/src/api/Jobs.ts b/services/frontend/src/api/Jobs.ts
new file mode 100644
index 0000000..3b816ce
--- /dev/null
+++ b/services/frontend/src/api/Jobs.ts
@@ -0,0 +1,28 @@
+import axios from "axios";
+import { notificationState } from "@/components/modals/NotificationState";
+import { Job } from "@/api/Models";
+
+const client = axios.create({
+  baseURL: " http://localhost:5002/",
+  headers: {
+    "Content-type": "application/json"
+  }
+});
+
+client.interceptors.response.use(undefined, error => {
+  notificationState.message = error.message;
+  notificationState.color = "#feb2b2";
+  notificationState.enabled = true;
+
+  return Promise.reject(error);
+});
+
+export async function GetJobs(): Promise<Job[]> {
+  return client.get("/jobs").then(resp => {
+    if (typeof resp !== "undefined") {
+      return resp.data;
+    } else {
+      return [];
+    }
+  });
+}
diff --git a/services/frontend/src/api/Models.ts b/services/frontend/src/api/Models.ts
index 04e0a0a..a7e4bb4 100644
--- a/services/frontend/src/api/Models.ts
+++ b/services/frontend/src/api/Models.ts
@@ -31,3 +31,57 @@ export interface User {
   Username: string;
   Password: string;
 }
+
+export interface Job {
+  PackageName: string;
+  Status: BuildStatus;
+  Logs: LogLine[];
+  Uuid: string;
+  Time: number;
+}
+
+export enum BuildStatus {
+  Pending,
+  PullingRepo,
+  Running,
+  Uploading,
+  Done,
+
+  Errored
+}
+
+export function BuildStatusToString(status: BuildStatus): string {
+  switch (status) {
+    case BuildStatus.Pending:
+      return "Queued";
+    case BuildStatus.PullingRepo:
+      return "Pulling repository";
+    case BuildStatus.Running:
+      return "Running";
+    case BuildStatus.Uploading:
+      return "Uploading";
+    case BuildStatus.Done:
+      return "Done";
+    case BuildStatus.Errored:
+      return "Errored";
+
+    default:
+      return "Unknown";
+  }
+}
+
+export enum LogLevel {
+  PanicLevel,
+  FatalLevel,
+  ErrorLevel,
+  WarnLevel,
+  InfoLevel,
+  DebugLevel,
+  TraceLevel
+}
+
+export interface LogLine {
+  Time: number;
+  Level: LogLevel;
+  message: string;
+}
diff --git a/services/frontend/src/components/Header.vue b/services/frontend/src/components/Header.vue
index edcc046..9e258e0 100644
--- a/services/frontend/src/components/Header.vue
+++ b/services/frontend/src/components/Header.vue
@@ -26,6 +26,17 @@
       >
         <span class="button">Users</span>
       </div>
+      <div
+        class="cursor-pointer flex flex-col items-center justify-center h-full"
+        @click="router.push('/jobs')"
+        v-bind:class="[
+          router.currentRoute.value.path !== '/jobs'
+            ? 'bg-primary'
+            : 'bg-primarylight'
+        ]"
+      >
+        <span class="button">Jobs</span>
+      </div>
 
       <div
         class="bg-primary cursor-pointer flex flex-col items-center justify-center h-full"
diff --git a/services/frontend/src/components/Search.vue b/services/frontend/src/components/Search.vue
index 2dee083..3513ef1 100644
--- a/services/frontend/src/components/Search.vue
+++ b/services/frontend/src/components/Search.vue
@@ -58,7 +58,7 @@
 <script lang="ts">
 import { defineComponent, reactive, ref } from "vue";
 import { NewResult, Result, search, ToPackage } from "@/api/AUR";
-import UpdatePackage from "@/components/UpdatePackage.vue";
+import UpdatePackage from "@/components/modals/UpdatePackage.vue";
 import { packages } from "@/api/packages";
 
 const gitUrlRegex = /(?:(?:git|ssh|https?)|(?:git@[\w.]+))(?::(\/\/)?)([\w.@:/\-~]+)(?:\.git)(\/)?/;
diff --git a/services/frontend/src/components/Dialog.vue b/services/frontend/src/components/modals/Dialog.vue
similarity index 100%
rename from services/frontend/src/components/Dialog.vue
rename to services/frontend/src/components/modals/Dialog.vue
diff --git a/services/frontend/src/components/Login.vue b/services/frontend/src/components/modals/Login.vue
similarity index 100%
rename from services/frontend/src/components/Login.vue
rename to services/frontend/src/components/modals/Login.vue
diff --git a/services/frontend/src/components/Notification.vue b/services/frontend/src/components/modals/Notification.vue
similarity index 93%
rename from services/frontend/src/components/Notification.vue
rename to services/frontend/src/components/modals/Notification.vue
index adadff6..7b7c4fc 100644
--- a/services/frontend/src/components/Notification.vue
+++ b/services/frontend/src/components/modals/Notification.vue
@@ -25,7 +25,7 @@
 
 <script lang="typescript">
 import { defineComponent } from "vue";
-import { notificationState } from "@/components/NotificationState";
+import { notificationState } from "@/components/modals/NotificationState";
 
 export default defineComponent({
   name: "Notification",
diff --git a/services/frontend/src/components/NotificationState.ts b/services/frontend/src/components/modals/NotificationState.ts
similarity index 100%
rename from services/frontend/src/components/NotificationState.ts
rename to services/frontend/src/components/modals/NotificationState.ts
diff --git a/services/frontend/src/components/UpdatePackage.vue b/services/frontend/src/components/modals/UpdatePackage.vue
similarity index 100%
rename from services/frontend/src/components/UpdatePackage.vue
rename to services/frontend/src/components/modals/UpdatePackage.vue
diff --git a/services/frontend/src/components/tables/JobsTable.vue b/services/frontend/src/components/tables/JobsTable.vue
new file mode 100644
index 0000000..96d6a5a
--- /dev/null
+++ b/services/frontend/src/components/tables/JobsTable.vue
@@ -0,0 +1,61 @@
+<template>
+  <div class="inline-block shadow rounded-lg overflow-hidden mt-2 min-w-full">
+    <table class="border-collapse min-w-full bg-white">
+      <tr class="bg-secondary text-white">
+        <th>Started</th>
+        <th>Name</th>
+        <th>Status</th>
+      </tr>
+      <tr v-for="job in jobs" v-bind:key="job.Name" class="row">
+        <td>{{ new Date(job.Time).toLocaleString() }}</td>
+        <td>{{ job.PackageName }}</td>
+        <td>{{ BuildStatusToString(job.Status) }}</td>
+      </tr>
+      <tr v-if="jobs.length === 0" class="text-center caption py-4">
+        There are no jobs currently scheduled.
+      </tr>
+    </table>
+  </div>
+</template>
+
+<script lang="ts">
+import { defineComponent, reactive } from "vue";
+import { GetJobs } from "@/api/Jobs";
+import { BuildStatusToString, Job } from "@/api/Models";
+
+export default defineComponent({
+  name: "JobsTable",
+  async setup() {
+    const jobs = reactive<Job[]>([]);
+
+    jobs.push(...(await GetJobs()));
+
+    return {
+      jobs,
+      BuildStatusToString
+    };
+  }
+});
+</script>
+
+<style scoped lang="postcss">
+th,
+td {
+  @apply px-5 text-center border-collapse py-2 table-cell border-b-2 border-gray-100 border-opacity-25;
+}
+
+.lastcolthinner {
+  width: 1%;
+  white-space: nowrap;
+}
+
+.caption {
+  /*
+  Spans a tr the entire width of the table, without using colspan=0. With colspan 0 there seems to be a
+  bug where text isn't centered. Only a positive non-zero integer allows text to be centered between columns,
+  which doesn't work as well for us because the columns can change (depending on simple vs non-simple layout)
+  */
+  display: table-caption;
+  caption-side: bottom;
+}
+</style>
diff --git a/services/frontend/src/components/PackageTable.vue b/services/frontend/src/components/tables/PackageTable.vue
similarity index 96%
rename from services/frontend/src/components/PackageTable.vue
rename to services/frontend/src/components/tables/PackageTable.vue
index 074aaeb..da85d12 100644
--- a/services/frontend/src/components/PackageTable.vue
+++ b/services/frontend/src/components/tables/PackageTable.vue
@@ -59,9 +59,9 @@
 import { defineComponent, ref } from "vue";
 import { frequencyToDuration, Package } from "@/api/Models";
 import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
-import UpdatePackage from "@/components/UpdatePackage.vue";
+import UpdatePackage from "@/components/modals/UpdatePackage.vue";
 import { DeletePackage, loggedIn } from "@/api/API";
-import Dialog from "@/components/Dialog.vue";
+import Dialog from "@/components/modals/Dialog.vue";
 import { loadPackages, packages } from "@/api/packages";
 
 export default defineComponent({
diff --git a/services/frontend/src/components/UsersTable.vue b/services/frontend/src/components/tables/UsersTable.vue
similarity index 97%
rename from services/frontend/src/components/UsersTable.vue
rename to services/frontend/src/components/tables/UsersTable.vue
index 68b4b27..2160fde 100644
--- a/services/frontend/src/components/UsersTable.vue
+++ b/services/frontend/src/components/tables/UsersTable.vue
@@ -68,9 +68,9 @@
 import { defineComponent, ref } from "vue";
 import { User } from "@/api/Models";
 import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
-import Dialog from "@/components/Dialog.vue";
+import Dialog from "@/components/modals/Dialog.vue";
 import { DeleteUser } from "@/api/API";
-import Login from "@/components/Login.vue";
+import Login from "@/components/modals/Login.vue";
 import { loadUsers, users } from "@/api/users";
 
 export default defineComponent({
diff --git a/services/frontend/src/router/index.ts b/services/frontend/src/router/index.ts
index 07a1849..5146ae2 100644
--- a/services/frontend/src/router/index.ts
+++ b/services/frontend/src/router/index.ts
@@ -10,6 +10,11 @@ const routes: Array<RouteRecordRaw> = [
     path: "/users",
     name: "Users",
     component: import("../views/Users.vue")
+  },
+  {
+    path: "/jobs",
+    name: "Jobs",
+    component: import("../views/Jobs.vue")
   }
 ];
 
diff --git a/services/frontend/src/views/Home.vue b/services/frontend/src/views/Home.vue
index 4753c6a..8b6a302 100644
--- a/services/frontend/src/views/Home.vue
+++ b/services/frontend/src/views/Home.vue
@@ -16,7 +16,7 @@
 
 <script lang="ts">
 import { defineComponent } from "vue";
-import PackageTable from "@/components/PackageTable.vue";
+import PackageTable from "@/components/tables/PackageTable.vue";
 import Search from "@/components/Search.vue";
 import { loggedIn } from "@/api/API";
 
diff --git a/services/frontend/src/views/Jobs.vue b/services/frontend/src/views/Jobs.vue
new file mode 100644
index 0000000..1779913
--- /dev/null
+++ b/services/frontend/src/views/Jobs.vue
@@ -0,0 +1,27 @@
+<template>
+  <div class="flex flex-col w-100 items-center align-middle">
+    <div class="lg:w-1/4 w-full p-2">
+      <Suspense>
+        <template #default>
+          <JobsTable />
+        </template>
+        <template #fallback>
+          <div>Loading...</div>
+        </template>
+      </Suspense>
+    </div>
+  </div>
+</template>
+
+<script lang="ts">
+import { defineComponent } from "vue";
+import JobsTable from "@/components/tables/JobsTable.vue";
+
+export default defineComponent({
+  name: "Jobs",
+  components: { JobsTable },
+  setup() {
+    return {};
+  }
+});
+</script>
diff --git a/services/frontend/src/views/Users.vue b/services/frontend/src/views/Users.vue
index e12c7c6..ded56aa 100644
--- a/services/frontend/src/views/Users.vue
+++ b/services/frontend/src/views/Users.vue
@@ -15,7 +15,7 @@
 
 <script lang="ts">
 import { defineComponent } from "vue";
-import UsersTable from "@/components/UsersTable.vue";
+import UsersTable from "@/components/tables/UsersTable.vue";
 
 export default defineComponent({
   name: "Users",