When to use Promise over observable?

An observable does everything that a promise does and more. It can always be switched to a promise with toPromise() method in case a promise is expected.

An observable must be chosen over a promise if

• any features that are intrinsic to observables and not promises and explained in detail in related question is in demand (notably unsubscription, incomplete observables and observables that receive multiple values)
• API that consumes it expects an observable and doesn't use Observable.from(...) safety structure to unify observables and promises

An observable may be chosen over a promise if the code where it's used uses observables exclusively.

A promise must be chosen over an observable if API that consumes it expects a promise and doesn't use Observable.from(...) safety structure.

A promise may be chosen over an observable if

• the code where it's used uses promises exclusively (notably async functions)
• it needs to be asynchronous by design
• it needs to be immediately subscribed and chained then, because a chain should be broken in observables let observable = ...; observable.subscribe(...); return observable (this also requires multiple subscriptions to be tracked in case an observable is cancellable)

Use Promise instead of an Observable, when:

• You need to handle the (future response) event no matter what (no unsubscribe, no cancel: after you subscribe, there will be an answer, 100%, and you will have to handle it, 100%, the code will get executed)
• One Subscription = One Event handling: there will be only one event from the source, so the future response and the completition is the same event.

Use Observable instead of a Promise, when:

• You want to have the ability to accept multiple events from the same source
• You need a "I am finished with this event stream" handler
• You want to be able to unsubscribe from a possibly never ending stream of data, and re-subscribe anytime (meaning also that you might don't really need to fulfill the subscription at all: for instance, if nothing happens in 10 sec, let's unsubscribe, nobody will ever handle the late answer)
• You want to use the RxJS "Stream API" to preprocess the data of your responses.

Generally, the Observable pattern is an extended Promise pattern, with a lot more tools and functionality. It is up to you to decide to limit the code with Promises or not. It was first a custom libary, then got included in ES2016.

Also, I suggest researching the issue with specific problem parameters: you need the app to be faster? You will use legacy modules?