diff --git a/utils/utils.go b/utils/utils.go
index ac9f064..7e2bf7c 100644
--- a/utils/utils.go
+++ b/utils/utils.go
@@ -18,12 +18,14 @@
 package utils
 
 import (
+	"crypto/md5"
 	"errors"
 	"fmt"
 	"io/ioutil"
 	"log"
 	"math/rand"
 	"path"
+	"sort"
 	"strings"
 
 	"github.com/golang/protobuf/jsonpb"
@@ -47,6 +49,116 @@
 	log.Println(strings.Join([]string{"\n##########\n", status, f, "Flow", "\n##########"}, " "))
 }
 
+func parseServiceFeed(serviceFeed string) ([]*fpb.Service, error) {
+	var feed fpb.ServiceFeed
+	content, err := ioutil.ReadFile(serviceFeed)
+	if err != nil {
+		return nil, fmt.Errorf("unable to read input file: %v", err)
+	}
+	if path.Ext(serviceFeed) == ".json" {
+		if err := jsonpb.UnmarshalString(string(content), &feed); err != nil {
+			return nil, fmt.Errorf("unable to parse feed as json: %v", err)
+		}
+	}
+	if path.Ext(serviceFeed) == ".pb3" {
+		if err := proto.Unmarshal(content, &feed); err != nil {
+			return nil, fmt.Errorf("unable to parse feed as pb3: %v", err)
+		}
+	}
+
+	if services := feed.GetService(); len(services) != 0 {
+		return services, nil
+	}
+	return nil, errors.New("service feed is empty. At least one service must be present in feed")
+}
+
+func merchantService(merchantID, serviceID string) string {
+	return strings.Join([]string{merchantID, serviceID}, "||")
+}
+
+func buildLineItem(availability *fpb.Availability, tickets []*fpb.TicketType) *mpb.LineItem {
+	lineItem := &mpb.LineItem{
+		ServiceId:   availability.GetServiceId(),
+		StartSec:    availability.GetStartSec(),
+		DurationSec: availability.GetDurationSec(),
+		Price:       &mpb.Price{},
+	}
+
+	// If not ticket types return nil as there is nothing to build.
+	if len(tickets) == 0 {
+		return nil
+	}
+
+	for i := 0; i < int(availability.GetSpotsOpen()); i++ {
+		// This deterministic which is fine given that we just want to get a mix of ticket types.
+		ticketTypeIndex := rand.Intn(len(tickets))
+		// Calculate price of line item.
+		if lineItem.GetPrice().GetCurrencyCode() == "" && tickets[ticketTypeIndex].GetPrice().GetCurrencyCode() != "" {
+			lineItem.Price.CurrencyCode = tickets[ticketTypeIndex].GetPrice().GetCurrencyCode()
+		}
+		lineItem.Price.PriceMicros += tickets[ticketTypeIndex].GetPrice().GetPriceMicros()
+
+		// Add ticket to line item.
+		lineItem.Tickets = append(lineItem.Tickets, &mpb.LineItem_OrderedTickets{
+			TicketId: tickets[ticketTypeIndex].GetTicketTypeId(),
+			Count:    1,
+		})
+	}
+
+	return lineItem
+}
+
+// MerchantLineItemMapFrom attempts to build a collection of LineItems from a service and availability feed.
+func MerchantLineItemMapFrom(serviceFeed, availabilityFeed string, testSlots int) (map[string][]*mpb.LineItem, error) {
+	services, err := parseServiceFeed(serviceFeed)
+	if err != nil {
+		return nil, err
+	}
+
+	feedHasTicketType := false
+	serviceTicketTypeMap := make(map[string][]*fpb.TicketType)
+	for _, service := range services {
+		merchantServiceID := merchantService(service.GetMerchantId(), service.GetServiceId())
+		for _, ticket := range service.GetTicketType() {
+			// TicketType can't have an empty price message or ticket_type_id. If it does it's excluded from map.
+			diff := cmp.Diff(&fpb.Price{}, ticket.GetPrice(), cmp.Comparer(proto.Equal))
+			if len(ticket.GetTicketTypeId()) == 0 || diff == "" {
+				continue
+			}
+
+			if _, ok := serviceTicketTypeMap[merchantServiceID]; !ok {
+				serviceTicketTypeMap[merchantServiceID] = []*fpb.TicketType{}
+			}
+			feedHasTicketType = true
+			serviceTicketTypeMap[merchantServiceID] = append(serviceTicketTypeMap[merchantServiceID], ticket)
+		}
+	}
+
+	if !feedHasTicketType {
+		return nil, errors.New("no valid ticket types found in service feed, please update service feed and retry")
+	}
+
+	availabilities, err := AvailabilityFrom(availabilityFeed, testSlots)
+	if err != nil {
+		return nil, err
+	}
+
+	merchantLineItemMap := make(map[string][]*mpb.LineItem)
+	for _, availability := range availabilities {
+		merchantServiceID := merchantService(availability.GetMerchantId(), availability.GetServiceId())
+		if tickets, ok := serviceTicketTypeMap[merchantServiceID]; ok {
+			lineItem := buildLineItem(availability, tickets)
+			// If lineItem can't be built, don't include in map
+			if lineItem == nil {
+				continue
+			}
+			merchantLineItemMap[availability.GetMerchantId()] = append(merchantLineItemMap[availability.GetMerchantId()], lineItem)
+		}
+	}
+
+	return merchantLineItemMap, nil
+}
+
 // AvailabilityFrom parses the file specified in availabilityFeed, returning a random permutation of availability data, maximum entries specified in testSlots
 func AvailabilityFrom(availabilityFeed string, testSlots int) ([]*fpb.Availability, error) {
 	LogFlow("Parse Input Feed", "Start")
@@ -89,7 +201,7 @@
 }
 
 // ValidateBooking performs granular comparisons between all got and want Bookings.
-func ValidateBooking(got *mpb.Booking, want *mpb.Booking) error {
+func ValidateBooking(got, want *mpb.Booking) error {
 	if got.GetBookingId() == "" {
 		return errors.New("booking_id is empty")
 	}
@@ -114,6 +226,136 @@
 	return nil
 }
 
+// ValidateLineItems performs granular comparisons between got and want LineItem arrays.
+func ValidateLineItems(got, want []*mpb.LineItem, confirmStatus bool) error {
+	if len(got) != len(want) {
+		return fmt.Errorf("number of LineItems differ got %d want %d", len(got), len(want))
+	}
+
+	for _, lineItem := range got {
+		orderTickets := OrderedTickets(lineItem.GetTickets())
+		sort.Sort(orderTickets)
+		lineItem.Tickets = orderTickets
+	}
+	for _, lineItem := range want {
+		orderTickets := OrderedTickets(lineItem.GetTickets())
+		sort.Sort(orderTickets)
+		lineItem.Tickets = orderTickets
+
+		if confirmStatus {
+			lineItem.Status = mpb.BookingStatus_CONFIRMED
+		}
+	}
+	sort.Sort(LineItems(got))
+	sort.Sort(LineItems(want))
+
+	if diff := cmp.Diff(got, want, cmp.Comparer(proto.Equal)); diff != "" {
+		return fmt.Errorf("LineItems differ (-got +want)\n%s", diff)
+	}
+
+	return nil
+}
+
+// ValidateOrder performs granular comparisons between got and want Order messages.
+// Params are purposely copied.
+func ValidateOrder(got, want mpb.Order) error {
+	if got.GetOrderId() == "" {
+		return fmt.Errorf("no order id provided for Order %v", got)
+	}
+	want.OrderId = got.GetOrderId()
+
+	if err := ValidateLineItems(got.GetItem(), want.GetItem(), true); err != nil {
+		return err
+	}
+
+	// LineItems okay. Remove, free memory, and compare rest of proto.
+	want.Item = nil
+	got.Item = nil
+	if diff := cmp.Diff(got, want, cmp.Comparer(proto.Equal)); diff != "" {
+		return fmt.Errorf("order protos differ. LineItems excluded, already validated. (-got +want)\n%s", diff)
+	}
+
+	return nil
+}
+
+// ValidateOrders performs simple comparisons and set up before forwarding orders
+// individually to ValidateOrder.
+func ValidateOrders(got, want Orders) error {
+	if len(got) != len(want) {
+		return fmt.Errorf("number of Orders differ got %d want %d", len(got), len(want))
+	}
+	sort.Sort(got)
+	sort.Sort(want)
+
+	var errorStrings []string
+	for i := 0; i < len(got); i++ {
+		if err := ValidateOrder(*got[i], *want[i]); err != nil {
+			errorStrings = append(errorStrings, err.Error())
+		}
+	}
+
+	if len(errorStrings) != 0 {
+		return errors.New(strings.Join(errorStrings, "\n"))
+	}
+	return nil
+}
+
+func hashLineItemByTicketIds(l *mpb.LineItem) string {
+	var uID []string
+	for _, ticket := range l.GetTickets() {
+		uID = append(uID, ticket.GetTicketId())
+	}
+	return fmt.Sprintf("%x", md5.Sum([]byte(strings.Join(uID, `|`))))
+}
+
+// Orders is a convenience type for an Orders array
+type Orders []*mpb.Order
+
+func (o Orders) Len() int {
+	return len(o)
+}
+
+func (o Orders) Less(i, j int) bool {
+	return o[i].GetOrderId() < o[j].GetOrderId()
+}
+
+func (o Orders) Swap(i, j int) {
+	o[i], o[j] = o[j], o[i]
+}
+
+// OrderedTickets is a convenience type for an OrderedTickets array
+type OrderedTickets []*mpb.LineItem_OrderedTickets
+
+func (ot OrderedTickets) Len() int {
+	return len(ot)
+}
+
+func (ot OrderedTickets) Less(i, j int) bool {
+	return ot[i].GetTicketId() < ot[j].GetTicketId()
+}
+
+func (ot OrderedTickets) Swap(i, j int) {
+	ot[i], ot[j] = ot[j], ot[i]
+}
+
+// LineItems is a convenience type for a LineItem array
+// This sort interface defined below should be used iff
+// OrderedTickets have already been sorted AND
+// ticket ids are UIDs
+type LineItems []*mpb.LineItem
+
+func (l LineItems) Len() int {
+	return len(l)
+}
+
+func (l LineItems) Less(i, j int) bool {
+	return hashLineItemByTicketIds(l[i]) < hashLineItemByTicketIds(l[j])
+}
+
+func (l LineItems) Swap(i, j int) {
+	l[i], l[j] = l[j], l[i]
+}
+
 // BuildSlotFrom creates a bookingservice slot from an feed availability record.
 func BuildSlotFrom(a *fpb.Availability) (*mpb.Slot, error) {
 	r := a.GetResources()