diff --git a/clientapi/clientapi.go b/clientapi/clientapi.go
index 8ac8f9449..1339f7c8c 100644
--- a/clientapi/clientapi.go
+++ b/clientapi/clientapi.go
@@ -23,9 +23,9 @@ import (
 	"github.com/matrix-org/dendrite/clientapi/routing"
 	"github.com/matrix-org/dendrite/common/basecomponent"
 	"github.com/matrix-org/dendrite/common/transactions"
+	eduServerAPI "github.com/matrix-org/dendrite/eduserver/api"
 	federationSenderAPI "github.com/matrix-org/dendrite/federationsender/api"
 	roomserverAPI "github.com/matrix-org/dendrite/roomserver/api"
-	typingServerAPI "github.com/matrix-org/dendrite/eduserver/api"
 	"github.com/matrix-org/gomatrixserverlib"
 	"github.com/sirupsen/logrus"
 )
@@ -41,13 +41,13 @@ func SetupClientAPIComponent(
 	aliasAPI roomserverAPI.RoomserverAliasAPI,
 	inputAPI roomserverAPI.RoomserverInputAPI,
 	queryAPI roomserverAPI.RoomserverQueryAPI,
-	typingInputAPI typingServerAPI.TypingServerInputAPI,
+	eduInputAPI eduServerAPI.EDUServerInputAPI,
 	asAPI appserviceAPI.AppServiceQueryAPI,
 	transactionsCache *transactions.Cache,
 	fedSenderAPI federationSenderAPI.FederationSenderQueryAPI,
 ) {
 	roomserverProducer := producers.NewRoomserverProducer(inputAPI, queryAPI)
-	typingProducer := producers.NewTypingServerProducer(typingInputAPI)
+	eduProducer := producers.NewEDUServerProducer(eduInputAPI)
 
 	userUpdateProducer := &producers.UserUpdateProducer{
 		Producer: base.KafkaProducer,
@@ -69,6 +69,6 @@ func SetupClientAPIComponent(
 	routing.Setup(
 		base.APIMux, base.Cfg, roomserverProducer, queryAPI, aliasAPI, asAPI,
 		accountsDB, deviceDB, federation, *keyRing, userUpdateProducer,
-		syncProducer, typingProducer, transactionsCache, fedSenderAPI,
+		syncProducer, eduProducer, transactionsCache, fedSenderAPI,
 	)
 }
diff --git a/clientapi/producers/typingserver.go b/clientapi/producers/eduserver.go
similarity index 75%
rename from clientapi/producers/typingserver.go
rename to clientapi/producers/eduserver.go
index 36cfaa967..14414ec64 100644
--- a/clientapi/producers/typingserver.go
+++ b/clientapi/producers/eduserver.go
@@ -20,20 +20,20 @@ import (
 	"github.com/matrix-org/gomatrixserverlib"
 )
 
-// TypingServerProducer produces events for the typing server to consume
-type TypingServerProducer struct {
-	InputAPI api.TypingServerInputAPI
+// EDUServerProducer produces events for the typing server to consume
+type EDUServerProducer struct {
+	InputAPI api.EDUServerInputAPI
 }
 
-// NewTypingServerProducer creates a new TypingServerProducer
-func NewTypingServerProducer(inputAPI api.TypingServerInputAPI) *TypingServerProducer {
-	return &TypingServerProducer{
+// NewEDUServerProducer creates a new EDUServerProducer
+func NewEDUServerProducer(inputAPI api.EDUServerInputAPI) *EDUServerProducer {
+	return &EDUServerProducer{
 		InputAPI: inputAPI,
 	}
 }
 
-// Send typing event to typing server
-func (p *TypingServerProducer) Send(
+// SendTyping sends a typing event to EDU server
+func (p *EDUServerProducer) SendTyping(
 	ctx context.Context, userID, roomID string,
 	typing bool, timeout int64,
 ) error {
diff --git a/clientapi/routing/routing.go b/clientapi/routing/routing.go
index 22ff12b02..91a1588cb 100644
--- a/clientapi/routing/routing.go
+++ b/clientapi/routing/routing.go
@@ -58,7 +58,7 @@ func Setup(
 	keyRing gomatrixserverlib.KeyRing,
 	userUpdateProducer *producers.UserUpdateProducer,
 	syncProducer *producers.SyncAPIProducer,
-	typingProducer *producers.TypingServerProducer,
+	eduProducer *producers.EDUServerProducer,
 	transactionsCache *transactions.Cache,
 	federationSender federationSenderAPI.FederationSenderQueryAPI,
 ) {
@@ -235,7 +235,7 @@ func Setup(
 			if err != nil {
 				return util.ErrorResponse(err)
 			}
-			return SendTyping(req, device, vars["roomID"], vars["userID"], accountDB, typingProducer)
+			return SendTyping(req, device, vars["roomID"], vars["userID"], accountDB, eduProducer)
 		}),
 	).Methods(http.MethodPut, http.MethodOptions)
 
diff --git a/clientapi/routing/sendtyping.go b/clientapi/routing/sendtyping.go
index 29953c32d..ffaa0e662 100644
--- a/clientapi/routing/sendtyping.go
+++ b/clientapi/routing/sendtyping.go
@@ -35,7 +35,7 @@ type typingContentJSON struct {
 func SendTyping(
 	req *http.Request, device *authtypes.Device, roomID string,
 	userID string, accountDB accounts.Database,
-	typingProducer *producers.TypingServerProducer,
+	eduProducer *producers.EDUServerProducer,
 ) util.JSONResponse {
 	if device.UserID != userID {
 		return util.JSONResponse{
@@ -69,10 +69,10 @@ func SendTyping(
 		return *resErr
 	}
 
-	if err = typingProducer.Send(
+	if err = eduProducer.SendTyping(
 		req.Context(), userID, roomID, r.Typing, r.Timeout,
 	); err != nil {
-		util.GetLogger(req.Context()).WithError(err).Error("typingProducer.Send failed")
+		util.GetLogger(req.Context()).WithError(err).Error("eduProducer.Send failed")
 		return jsonerror.InternalServerError()
 	}
 
diff --git a/cmd/dendrite-typing-server/main.go b/cmd/dendrite-edu-server/main.go
similarity index 86%
rename from cmd/dendrite-typing-server/main.go
rename to cmd/dendrite-edu-server/main.go
index 0be9acc96..8d5239ab7 100644
--- a/cmd/dendrite-typing-server/main.go
+++ b/cmd/dendrite-edu-server/main.go
@@ -30,8 +30,8 @@ func main() {
 		}
 	}()
 
-	eduserver.SetupTypingServerComponent(base, cache.NewTypingCache())
+	eduserver.SetupEDUServerComponent(base, cache.New())
 
-	base.SetupAndServeHTTP(string(base.Cfg.Bind.TypingServer), string(base.Cfg.Listen.TypingServer))
+	base.SetupAndServeHTTP(string(base.Cfg.Bind.EDUServer), string(base.Cfg.Listen.EDUServer))
 
 }
diff --git a/common/basecomponent/base.go b/common/basecomponent/base.go
index 341e176f2..8d559f4dc 100644
--- a/common/basecomponent/base.go
+++ b/common/basecomponent/base.go
@@ -111,10 +111,10 @@ func (b *BaseDendrite) CreateHTTPRoomserverAPIs() (
 	return alias, input, query
 }
 
-// CreateHTTPEDUServerAPIs returns typingInputAPI for hitting the typing
+// CreateHTTPEDUServerAPIs returns eduInputAPI for hitting the EDU
 // server over HTTP
-func (b *BaseDendrite) CreateHTTPEDUServerAPIs() eduServerAPI.TypingServerInputAPI {
-	return eduServerAPI.NewTypingServerInputAPIHTTP(b.Cfg.EDUServerURL(), nil)
+func (b *BaseDendrite) CreateHTTPEDUServerAPIs() eduServerAPI.EDUServerInputAPI {
+	return eduServerAPI.NewEDUServerInputAPIHTTP(b.Cfg.EDUServerURL(), nil)
 }
 
 // CreateHTTPFederationSenderAPIs returns FederationSenderQueryAPI for hitting
diff --git a/common/config/config_test.go b/common/config/config_test.go
index 110c8b84c..b72f5fad0 100644
--- a/common/config/config_test.go
+++ b/common/config/config_test.go
@@ -62,7 +62,7 @@ listen:
   sync_api: "localhost:7773"
   media_api: "localhost:7774"
   appservice_api: "localhost:7777"
-  typing_server: "localhost:7778"
+  edu_server: "localhost:7778"
 logging:
   - type: "file"
     level: "info"
diff --git a/common/test/config.go b/common/test/config.go
index 0fed252ae..f88e45125 100644
--- a/common/test/config.go
+++ b/common/test/config.go
@@ -106,7 +106,7 @@ func MakeConfig(configDir, kafkaURI, database, host string, startPort int) (*con
 	cfg.Listen.RoomServer = assignAddress()
 	cfg.Listen.SyncAPI = assignAddress()
 	cfg.Listen.PublicRoomsAPI = assignAddress()
-	cfg.Listen.TypingServer = assignAddress()
+	cfg.Listen.EDUServer = assignAddress()
 
 	// Bind to the same address as the listen address
 	// All microservices are run on the same host in testing
@@ -117,7 +117,7 @@ func MakeConfig(configDir, kafkaURI, database, host string, startPort int) (*con
 	cfg.Bind.RoomServer = cfg.Listen.RoomServer
 	cfg.Bind.SyncAPI = cfg.Listen.SyncAPI
 	cfg.Bind.PublicRoomsAPI = cfg.Listen.PublicRoomsAPI
-	cfg.Bind.TypingServer = cfg.Listen.TypingServer
+	cfg.Bind.EDUServer = cfg.Listen.EDUServer
 
 	return &cfg, port, nil
 }
diff --git a/eduserver/api/input.go b/eduserver/api/input.go
index ae9e3c5ca..c95acaf16 100644
--- a/eduserver/api/input.go
+++ b/eduserver/api/input.go
@@ -36,7 +36,7 @@ type InputTypingEvent struct {
 	OriginServerTS gomatrixserverlib.Timestamp `json:"origin_server_ts"`
 }
 
-// InputTypingEventRequest is a request to TypingServerInputAPI
+// InputTypingEventRequest is a request to EDUServerInputAPI
 type InputTypingEventRequest struct {
 	InputTypingEvent InputTypingEvent `json:"input_typing_event"`
 }
@@ -44,8 +44,8 @@ type InputTypingEventRequest struct {
 // InputTypingEventResponse is a response to InputTypingEvents
 type InputTypingEventResponse struct{}
 
-// TypingServerInputAPI is used to write events to the typing server.
-type TypingServerInputAPI interface {
+// EDUServerInputAPI is used to write events to the typing server.
+type EDUServerInputAPI interface {
 	InputTypingEvent(
 		ctx context.Context,
 		request *InputTypingEventRequest,
@@ -53,24 +53,24 @@ type TypingServerInputAPI interface {
 	) error
 }
 
-// TypingServerInputTypingEventPath is the HTTP path for the InputTypingEvent API.
-const TypingServerInputTypingEventPath = "/api/eduserver/input"
+// EDUServerInputTypingEventPath is the HTTP path for the InputTypingEvent API.
+const EDUServerInputTypingEventPath = "/api/eduserver/input"
 
-// NewTypingServerInputAPIHTTP creates a TypingServerInputAPI implemented by talking to a HTTP POST API.
-func NewTypingServerInputAPIHTTP(typingServerURL string, httpClient *http.Client) TypingServerInputAPI {
+// NewEDUServerInputAPIHTTP creates a EDUServerInputAPI implemented by talking to a HTTP POST API.
+func NewEDUServerInputAPIHTTP(eduServerURL string, httpClient *http.Client) EDUServerInputAPI {
 	if httpClient == nil {
 		httpClient = http.DefaultClient
 	}
-	return &httpTypingServerInputAPI{typingServerURL, httpClient}
+	return &httpEDUServerInputAPI{eduServerURL, httpClient}
 }
 
-type httpTypingServerInputAPI struct {
-	typingServerURL string
-	httpClient      *http.Client
+type httpEDUServerInputAPI struct {
+	eduServerURL string
+	httpClient   *http.Client
 }
 
-// InputRoomEvents implements TypingServerInputAPI
-func (h *httpTypingServerInputAPI) InputTypingEvent(
+// InputRoomEvents implements EDUServerInputAPI
+func (h *httpEDUServerInputAPI) InputTypingEvent(
 	ctx context.Context,
 	request *InputTypingEventRequest,
 	response *InputTypingEventResponse,
@@ -78,6 +78,6 @@ func (h *httpTypingServerInputAPI) InputTypingEvent(
 	span, ctx := opentracing.StartSpanFromContext(ctx, "InputTypingEvent")
 	defer span.Finish()
 
-	apiURL := h.typingServerURL + TypingServerInputTypingEventPath
+	apiURL := h.eduServerURL + EDUServerInputTypingEventPath
 	return commonHTTP.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
 }
diff --git a/eduserver/cache/cache.go b/eduserver/cache/cache.go
index b93f21b0c..46f7a2b13 100644
--- a/eduserver/cache/cache.go
+++ b/eduserver/cache/cache.go
@@ -32,8 +32,8 @@ type roomData struct {
 	userSet      userSet
 }
 
-// TypingCache maintains a list of users typing in each room.
-type TypingCache struct {
+// EDUCache maintains a list of users typing in each room.
+type EDUCache struct {
 	sync.RWMutex
 	latestSyncPosition int64
 	data               map[string]*roomData
@@ -42,26 +42,26 @@ type TypingCache struct {
 
 // Create a roomData with its sync position set to the latest sync position.
 // Must only be called after locking the cache.
-func (t *TypingCache) newRoomData() *roomData {
+func (t *EDUCache) newRoomData() *roomData {
 	return &roomData{
 		syncPosition: t.latestSyncPosition,
 		userSet:      make(userSet),
 	}
 }
 
-// New returns a new TypingCache initialised for use.
-func New() *TypingCache {
-	return &TypingCache{data: make(map[string]*roomData)}
+// New returns a new EDUCache initialised for use.
+func New() *EDUCache {
+	return &EDUCache{data: make(map[string]*roomData)}
 }
 
 // SetTimeoutCallback sets a callback function that is called right after
 // a user is removed from the typing user list due to timeout.
-func (t *TypingCache) SetTimeoutCallback(fn TimeoutCallbackFn) {
+func (t *EDUCache) SetTimeoutCallback(fn TimeoutCallbackFn) {
 	t.timeoutCallback = fn
 }
 
 // GetTypingUsers returns the list of users typing in a room.
-func (t *TypingCache) GetTypingUsers(roomID string) []string {
+func (t *EDUCache) GetTypingUsers(roomID string) []string {
 	users, _ := t.GetTypingUsersIfUpdatedAfter(roomID, 0)
 	// 0 should work above because the first position used will be 1.
 	return users
@@ -70,7 +70,7 @@ func (t *TypingCache) GetTypingUsers(roomID string) []string {
 // GetTypingUsersIfUpdatedAfter returns all users typing in this room with
 // updated == true if the typing sync position of the room is after the given
 // position. Otherwise, returns an empty slice with updated == false.
-func (t *TypingCache) GetTypingUsersIfUpdatedAfter(
+func (t *EDUCache) GetTypingUsersIfUpdatedAfter(
 	roomID string, position int64,
 ) (users []string, updated bool) {
 	t.RLock()
@@ -93,7 +93,7 @@ func (t *TypingCache) GetTypingUsersIfUpdatedAfter(
 // expire is the time when the user typing should time out.
 // if expire is nil, defaultTypingTimeout is assumed.
 // Returns the latest sync position for typing after update.
-func (t *TypingCache) AddTypingUser(
+func (t *EDUCache) AddTypingUser(
 	userID, roomID string, expire *time.Time,
 ) int64 {
 	expireTime := getExpireTime(expire)
@@ -111,7 +111,7 @@ func (t *TypingCache) AddTypingUser(
 
 // addUser with mutex lock & replace the previous timer.
 // Returns the latest typing sync position after update.
-func (t *TypingCache) addUser(
+func (t *EDUCache) addUser(
 	userID, roomID string, expiryTimer *time.Timer,
 ) int64 {
 	t.Lock()
@@ -143,7 +143,7 @@ func (t *TypingCache) addUser(
 
 // RemoveUser with mutex lock & stop the timer.
 // Returns the latest sync position for typing after update.
-func (t *TypingCache) RemoveUser(userID, roomID string) int64 {
+func (t *EDUCache) RemoveUser(userID, roomID string) int64 {
 	t.Lock()
 	defer t.Unlock()
 
@@ -166,7 +166,7 @@ func (t *TypingCache) RemoveUser(userID, roomID string) int64 {
 	return t.latestSyncPosition
 }
 
-func (t *TypingCache) GetLatestSyncPosition() int64 {
+func (t *EDUCache) GetLatestSyncPosition() int64 {
 	t.Lock()
 	defer t.Unlock()
 	return t.latestSyncPosition
diff --git a/eduserver/cache/cache_test.go b/eduserver/cache/cache_test.go
index 2a6ffa50e..8a1b6f797 100644
--- a/eduserver/cache/cache_test.go
+++ b/eduserver/cache/cache_test.go
@@ -19,10 +19,10 @@ import (
 	"github.com/matrix-org/dendrite/common/test"
 )
 
-func TestTypingCache(t *testing.T) {
-	tCache := NewTypingCache()
+func TestEDUCache(t *testing.T) {
+	tCache := New()
 	if tCache == nil {
-		t.Fatal("NewTypingCache failed")
+		t.Fatal("New failed")
 	}
 
 	t.Run("AddTypingUser", func(t *testing.T) {
@@ -38,7 +38,7 @@ func TestTypingCache(t *testing.T) {
 	})
 }
 
-func testAddTypingUser(t *testing.T, tCache *TypingCache) { // nolint: unparam
+func testAddTypingUser(t *testing.T, tCache *EDUCache) { // nolint: unparam
 	present := time.Now()
 	tests := []struct {
 		userID string
@@ -58,7 +58,7 @@ func testAddTypingUser(t *testing.T, tCache *TypingCache) { // nolint: unparam
 	}
 }
 
-func testGetTypingUsers(t *testing.T, tCache *TypingCache) {
+func testGetTypingUsers(t *testing.T, tCache *EDUCache) {
 	tests := []struct {
 		roomID    string
 		wantUsers []string
@@ -75,7 +75,7 @@ func testGetTypingUsers(t *testing.T, tCache *TypingCache) {
 	}
 }
 
-func testRemoveUser(t *testing.T, tCache *TypingCache) {
+func testRemoveUser(t *testing.T, tCache *EDUCache) {
 	tests := []struct {
 		roomID  string
 		userIDs []string
diff --git a/eduserver/eduserver.go b/eduserver/eduserver.go
index 48ca97cfb..8ddd2c527 100644
--- a/eduserver/eduserver.go
+++ b/eduserver/eduserver.go
@@ -27,9 +27,9 @@ import (
 // APIs directly instead of having to use HTTP.
 func SetupEDUServerComponent(
 	base *basecomponent.BaseDendrite,
-	eduCache *cache.TypingCache,
-) api.TypingServerInputAPI {
-	inputAPI := &input.TypingServerInputAPI{
+	eduCache *cache.EDUCache,
+) api.EDUServerInputAPI {
+	inputAPI := &input.EDUServerInputAPI{
 		Cache:                  eduCache,
 		Producer:               base.KafkaProducer,
 		OutputTypingEventTopic: string(base.Cfg.Kafka.Topics.OutputTypingEvent),
diff --git a/eduserver/input/input.go b/eduserver/input/input.go
index 6ad1b8830..e0cc6922a 100644
--- a/eduserver/input/input.go
+++ b/eduserver/input/input.go
@@ -26,18 +26,18 @@ import (
 	"gopkg.in/Shopify/sarama.v1"
 )
 
-// TypingServerInputAPI implements api.TypingServerInputAPI
-type TypingServerInputAPI struct {
+// EDUServerInputAPI implements api.EDUServerInputAPI
+type EDUServerInputAPI struct {
 	// Cache to store the current typing members in each room.
-	Cache *cache.TypingCache
+	Cache *cache.EDUCache
 	// The kafka topic to output new typing events to.
 	OutputTypingEventTopic string
 	// kafka producer
 	Producer sarama.SyncProducer
 }
 
-// InputTypingEvent implements api.TypingServerInputAPI
-func (t *TypingServerInputAPI) InputTypingEvent(
+// InputTypingEvent implements api.EDUServerInputAPI
+func (t *EDUServerInputAPI) InputTypingEvent(
 	ctx context.Context,
 	request *api.InputTypingEventRequest,
 	response *api.InputTypingEventResponse,
@@ -56,7 +56,7 @@ func (t *TypingServerInputAPI) InputTypingEvent(
 	return t.sendEvent(ite)
 }
 
-func (t *TypingServerInputAPI) sendEvent(ite *api.InputTypingEvent) error {
+func (t *EDUServerInputAPI) sendEvent(ite *api.InputTypingEvent) error {
 	ev := &api.TypingEvent{
 		Type:   gomatrixserverlib.MTyping,
 		RoomID: ite.RoomID,
@@ -89,9 +89,9 @@ func (t *TypingServerInputAPI) sendEvent(ite *api.InputTypingEvent) error {
 	return err
 }
 
-// SetupHTTP adds the TypingServerInputAPI handlers to the http.ServeMux.
-func (t *TypingServerInputAPI) SetupHTTP(servMux *http.ServeMux) {
-	servMux.Handle(api.TypingServerInputTypingEventPath,
+// SetupHTTP adds the EDUServerInputAPI handlers to the http.ServeMux.
+func (t *EDUServerInputAPI) SetupHTTP(servMux *http.ServeMux) {
+	servMux.Handle(api.EDUServerInputTypingEventPath,
 		common.MakeInternalAPI("inputTypingEvents", func(req *http.Request) util.JSONResponse {
 			var request api.InputTypingEventRequest
 			var response api.InputTypingEventResponse
diff --git a/syncapi/storage/postgres/syncserver.go b/syncapi/storage/postgres/syncserver.go
index 9b27b989b..ead1bf335 100644
--- a/syncapi/storage/postgres/syncserver.go
+++ b/syncapi/storage/postgres/syncserver.go
@@ -53,7 +53,7 @@ type SyncServerDatasource struct {
 	events              outputRoomEventsStatements
 	roomstate           currentRoomStateStatements
 	invites             inviteEventsStatements
-	eduCache            *cache.TypingCache
+	eduCache            *cache.EDUCache
 	topology            outputRoomEventsTopologyStatements
 	backwardExtremities backwardExtremitiesStatements
 }
diff --git a/syncapi/storage/sqlite3/syncserver.go b/syncapi/storage/sqlite3/syncserver.go
index 8f2bcf67b..30f77e54d 100644
--- a/syncapi/storage/sqlite3/syncserver.go
+++ b/syncapi/storage/sqlite3/syncserver.go
@@ -57,7 +57,7 @@ type SyncServerDatasource struct {
 	events              outputRoomEventsStatements
 	roomstate           currentRoomStateStatements
 	invites             inviteEventsStatements
-	eduCache            *cache.TypingCache
+	eduCache            *cache.EDUCache
 	topology            outputRoomEventsTopologyStatements
 	backwardExtremities backwardExtremitiesStatements
 }