Question: I have a publicly accessible ms access file - Frontend.accdb for which all tables are linked to another protected ms access database called Data.accdb. An import job is defined in the data.accdb which brings data into the data.accdb which will be updated to Frontend.accdb when opened. 

I want to add this import job in my `frontend.accdb` so that by clicking a button in the frontend.accdb, data.accdb gets refreshed and the tables inside Frontend.accdb is populated with fresh data.

Answer: 
Semantics of these technologies are different because they were designed to support different scenarios:

* SNS/SQS: the items in the stream **are not** related to each other
* Kinesis: the items in the stream **are** related to each other

Let's understand the difference by example. 

1. Suppose we have a stream of orders, for each order we need to reserve some stock and schedule a delivery. Once this is complete, we can safely remove the item from the stream and start processing the next order. We are fully *done* with the previous order before we start the next one.
2. Again, we have the same stream of orders, but now our goal is to group orders by destinations. Once we have, say, 10 orders to the same place, we want to deliver them together (delivery optimization). Now the story is different: when we get a new item from the stream, we cannot finish processing it; rather we "wait" for more items to come in order to meet our goal. Moreover, if the processor process crashes, we must "restore" the state (so no order will be lost).

Once processing of one item cannot be separated from processing another one, we must have Kinesis semantics in order to handle all the cases safely.
Excerpt from [AWS Documentation](https://aws.amazon.com/kinesis/streams/faqs/):

> 
> **We recommend Amazon Kinesis Streams for use cases with requirements that are similar to the following:**
> 
> 
> * Routing related records to the same record processor (as in streaming MapReduce). For example, counting and aggregation are simpler when all records for a given key are routed to the same record processor.
> * Ordering of records. For example, you want to transfer log data from the application host to the processing/archival host while maintaining the order of log statements.
> * Ability for multiple applications to consume the same stream concurrently. For example, you have one application that updates a real-time dashboard and another that archives data to Amazon Redshift. You want both applications to consume data from the same stream concurrently and independently.
> * Ability to consume records in the same order a few hours later. For example, you have a billing application and an audit application that runs a few hours behind the billing application. Because Amazon Kinesis Streams stores data for up to 7 days, you can run the audit application up to 7 days behind the billing application.
> 
> 
> **We recommend Amazon SQS for use cases with requirements that are similar to the following:**
> 
> 
> * Messaging semantics (such as message-level ack/fail) and visibility timeout. For example, you have a queue of work items and want to track the successful completion of each item independently. Amazon SQS tracks the ack/fail, so the application does not have to maintain a persistent checkpoint/cursor. Amazon SQS will delete acked messages and redeliver failed messages after a configured visibility timeout.
> * Individual message delay. For example, you have a job queue and need to schedule individual jobs with a delay. With Amazon SQS, you can configure individual messages to have a delay of up to 15 minutes.
> * Dynamically increasing concurrency/throughput at read time. For example, you have a work queue and want to add more readers until the backlog is cleared. With Amazon Kinesis Streams, you can scale up to a sufficient number of shards (note, however, that you'll need to provision enough shards ahead of time).
> * Leveraging Amazon SQS’s ability to scale transparently. For example, you buffer requests and the load changes as a result of occasional load spikes or the natural growth of your business. Because each buffered request can be processed independently, Amazon SQS can scale transparently to handle the load without any provisioning instructions from you.
> 
> 
>