Comparison of AWS and Tilores Entity Resolution Software
Author: Hendrik Nehnes, Co-founder, Tilores. Reviewer: Steven Renwick, CEO, Tilores (pending confirmation before publication).
TL;DR: On the same 10-record test, Tilores — a real-time entity resolution API — matched each record in milliseconds as it was inserted and resolved the data to the correct 4 entities after about 3 minutes of setup. AWS Entity Resolution, a batch service at the time of the test, took 9–11 minutes and matched to 7 entities (rules) or none (ML). Since then AWS has added near-real-time matching (June 2025) that returns a match ID "within seconds" via its Generate Match ID API — though AWS notes near-real-time is not available for advanced fuzzy matching — while Tilores matches at insertion in milliseconds, fuzzy matching included, with simultaneous search via its GraphQL API. So in 2026 the real question is not "batch or not" but how low the matching latency goes and whether fuzzy matching is part of it.
How fast are real-time entity resolution APIs compared to batch matching?
This comparison ran both systems on the same unnormalized 10-record CSV that should resolve to four people. The table summarises what each system did; the full walk-through, screenshots, and result tables are preserved in the sections below.
| Criteria | AWS Entity Resolution | Tilores |
|---|---|---|
| Processing model | Batch at the time of this test; near-real-time matching added June 2025 — returns a match ID "within seconds" via the Generate Match ID API, but not available for advanced fuzzy matching | Real-time — matches each record at insertion in milliseconds, fuzzy matching included, with simultaneous search |
| Time to result (this test) | 9–11 minutes (environment setup + batch resolution job) | ~3 minute setup; matching itself takes a few milliseconds |
| Matching accuracy (target = 4 clusters) | ML: 0 matches (10 entities); Rules: 7 entities | 4 entities (correct), no fine-tuning |
| Setup effort | ≥1 hour for non-AWS users; minutes for AWS experts; needs S3, Glue, IAM, Entity Resolution | 4 clicks; built-in AI proposes preconfigured rules |
| Matching techniques | Rule-based or ML (ML not user-trainable in this test); incremental ML matching added 2026; data-service-provider IDs (e.g. Ramp ID, TruAudience, UID2.0) | OR-connected rules with a confidence score per link; configurable for person and company data |
| Deployment | AWS-native, tightly integrated into the AWS ecosystem | Deployable into a customer's AWS account or as SaaS; on AWS Marketplace; custom GraphQL API |
In our data-driven world, the information accuracy is crucial for company success. However, ensuring this accuracy becomes a daunting task when data contains redundant or inconsistent entries for the same real-world entities. An "entity" could represent a person, a company, a machine, or any other tangible or intangible object.
Fortunately, entity resolution software comes to the rescue by efficiently linking and deduplicating these scattered pieces of information. These systems work to create a clean and accessible datasets, free from redundancies, while preserving all essential information in a deduplicated manner. By harmonizing the data and eliminating duplicates, entity resolution systems empower organizations to make more reliable and informed decisions based on a unified view of their data.
The ER systems in this comparison have different features and functionalities however the result should be the same - clean, properly matched data.
As the topic of entity resolution can be quite complex, ER systems should provide a simple way to start matching the data quickly and functionalities to then fine-tune the matching process.
General Setup
We use 10 records of persons with similar names and same address. These records are stored in one csv file as both systems are able to work with csv. The file is not normalized and contains some spaces in the data.
The resulting matching table should not mix up two different persons, but also should not miss any records that belong to the same person.
As we can see with this data we should retrieve 4 different clusters based on the data:
| Cluster ID | Record IDs |
|---|---|
| 1 | 1, 2, 3, 4, 8, 9 |
| 2 | 5, 6 |
| 3 | 7 |
| 4 | 10 |
AWS Entity Resolution
Editor's note (2026): this hands-on walkthrough reflects AWS Entity Resolution as it worked at launch. AWS has since added near-real-time matching and other capabilities — see What's changed since this comparison below. The original test narrative is preserved as a point-in-time record.
AWS recently launched their own Entity Resolution service. This service can be either configured to use rules or machine learning for matching. Currently the service runs as a batch service and has no real time capabilities. The configurability is very limited at the moment and the matching of records is only possible for personal data like name and address. As the service was just started a few weeks ago, it is likely that the capabilities will be extended soon.
Product Page: https://aws.amazon.com/de/entity-resolution/
Documentation: https://docs.aws.amazon.com/entityresolution/latest/userguide/setting-up.html
Requirements:
- AWS Account (best with Administrator permissions as you need to use different services)
- AWS S3 for the input and result files
- AWS Glue to create the tables
- AWS IAM to create the needed roles to access all needed services
- AWS Entity Resolution for the final matching of the data
Setup:
First the setup of the required infrastructure, services and data load into a glue table has to be done. Next you need to create a schema mapping and define which columns should be used for matching and which are passed through. Then you group the input fields to be able to match them.
Based on the matching technique there are now two different flows:
- ML based: This technique does not need any configuration and tries to match the records based on a machine learning model. The model cannot be changed or trained by the user. So this is a fast way to do entity resolution but for our test case the results were not good as the model did not match any records.
- Rule based: Using the rule based matching, rules can be defined that match the data. The rules have priorities so that the first rule that matches two records is used and then the processing for this record is stopped. For rule based matching the cadence for the matching runs can be defined (this is not available for the ML process). For the test we choose manual but for changing data it makes sense to use the automatic cadence that starts the job whenever the data is changed.
Different combinations of the match keys can be used as seen in the screenshot below. As with every entity resolution system, the more independent attributes available the better the matching can be.
As the matching keys contain several attributes like first name and last name, the user can choose how the matching should be done by selecting the comparison type.
Results:
ML based
| Cluster ID | Record IDs |
|---|---|
| 1 | 1 |
| 2 | 2 |
| 3 | 3 |
| 4 | 4 |
| 5 | 5 |
| 6 | 6 |
| 7 | 7 |
| 8 | 8 |
| 9 | 9 |
| 10 | 10 |
The ML based approach delivers zero matches and does not allow any additional configuration.
Rule based
| Cluster ID | Record IDs |
|---|---|
| 972d03fa0efc489c9707e4756e7867e9 | 7 |
| 5291e16cc8c14368a5db34760a6c9c3f | 9 |
| 23b30c5fd03a3407b61aaa932cc74eb2 | 3, 2, 1 |
| 303f56fbf9ce472cb34ad1ebbdf1d8d9 | 10 |
| 7bda65da2d66499daad1438773658105 | 4 |
| 6de6133e05b43af4ba9a22245cb02358 | 5, 6 |
| f4f85d56361e405588337896dde55af2 | 8 |
The rules based approach allows to configure simple rules for the matching. The rest of the process is similar to the ML based approach. For the rule based approach the records were matched to 7 resulting entities.
Tilores
Tilores is an entity resolution software that links and deduplicates record data in real-time. Data can be searched simultaneously as data is inserted into Tilores. The software can be deployed into a customer's AWS account or used as a SaaS service. This test uses the public SaaS service's UI.
Tilores can be configured for all kinds of data, including person and company matching and deduplication.
Product Page: https://tilores.io/
Documentation: https://docs.tilotech.io/
AWS Marketplace: https://aws.amazon.com/marketplace/pp/prodview-2yn5oirwdwq74?sr=0-1&ref_=beagle&applicationId=AWSMPContessa
Requirements:
- Registration using email/password or google signup at app.tilores.io (the service can be tested for free)
Setup:
After successful signup, the user can select if a sample file shall be provided by Tilores, if a customer's file is to be uploaded (this is the option we used for the test) or if Tilores should be configured manually.
The first step is to upload the sample file
Tilores built-in AI recognized the data and proposes to use preconfigured rules for this use case:
Using this configuration Tilores now sets up an instance for us and ingests the data.
When the deployment is done, one of the entities is shown using the Tilores search UI.
The whole setup needed 4 clicks from the user, the rest was done automatically.
Usually, data is uploaded to Tilores and also searched using the custom GraphQL API that is part of every instance.
For the test, the setup process configured two rules that match on name and address. In Tilores, the rules are OR connected which means that always all rules are executed which results in a confidence score for each link.
As the data was not normalized and contained white spaces, the data had to be transformed by the system before matching. This is done using the field transformation and extraction that was automatically configured during the setup of the instance. Based on the use case this can further be fine tuned.
For analytics, exports and to provide clean data for machine learning, the Tilores analytics engine can be used. For the test it was used to export the data.
Results:
| Cluster ID | Record IDs |
|---|---|
| 976a6fdc-f6da-4719-920d-8c60f0fe6c91 | 1, 2, 3, 4, 8, 9 |
| dda2d449-03d2-461d-9012-326b7b01d2ee | 5, 6 |
| 5b92221d-df4f-4acc-aaf8-bcfe0f0aac75 | 7 |
| b41199ac-2fb3-44a5-ad87-0ba7ca05e31b | 10 |
The result shows 4 entities. This was achieved without any additional fine-tuning.
Conclusion
The main criteria for entity resolution (ER) use cases is the matching quality, second comes the usability, third the performance.
AWS created a new ER service to meet the increasing demand for quality entity data and integrated it tightly into their ecosystem. As with every AWS service, it is expected that this is just the start and more features will be added based on the customer demand.
Tilores is a patent-pending technology that is used by diverse customers with a wealth of features to be configured for all different ER use cases.
To keep this comparison fair, only the simplest possible configuration was used for both systems.
For criteria 1, AWS Entity Resolution Service matched the records in best case (rules) to 7 entities. Tilores matched the records to 4 entities.
Criteria 2 shows how tightly the AWS service is integrated into its ecosystem. Many other AWS services are utilized but also the connectivity to other services is possible in this way. For non-AWS users the configuration will take at least one hour, for AWS experts only a few minutes as a detailed documentation was created. Tilores on the other hand only needs 4 clicks to match the records.
Criteria 3: AWS ER needed between 9 and 11 minutes to run the test. We expect that this time is needed to set up the whole environment and then to run the resolution job. This will be tested again with a bigger dataset. Tilores setup took 3 minutes. As for the AWS ER setup, first the instance has to be deployed. The matching itself only takes a few milliseconds.
What's changed since this comparison? (2026 update)
The hands-on test above reflects AWS Entity Resolution at launch, when it was batch-only. AWS has since expanded the service, so the current picture is more nuanced than "batch vs real-time":
- Near-real-time matching (June 2025). AWS added near-real-time matching: via the Generate Match ID API it compares an incoming record against existing records and returns a consistent match ID "within seconds." AWS notes this near-real-time path is not available for advanced rule-based fuzzy matching.
- Incremental ML matching (2026). AWS added incremental machine-learning matching workflows, so ML matches can update as new data arrives rather than only in full batch runs.
- Three matching approaches. Per the AWS Entity Resolution FAQs, the service now offers rule-based, ML-powered, and data-service-provider matching (matching to third-party IDs such as Ramp ID, TruAudience, and UID2.0).
Where does that leave the real-time question? Near-real-time and real-time are not identical. AWS returns a match "within seconds" through an API call and excludes advanced fuzzy matching from that path; Tilores matches and links each record at insertion in milliseconds — fuzzy matching included — and the resolved data is searchable simultaneously through the Tilores GraphQL API, deployable in your own AWS account or as SaaS. For periodic, large-scale dedupe a batch workflow is often the right tool; for matching at the moment of ingestion with fuzzy matching in the loop, a real-time API is still the closer fit.
See it on your own data: create a free Tilores account and match a sample file in a few clicks, or explore Tilores entity resolution software and the Tilores platform to deploy real-time matching in your own AWS account or as SaaS.
Frequently asked questions
- How fast are real-time entity resolution APIs compared to batch matching?
- They operate on different time scales. A batch service such as AWS Entity Resolution runs matching as a scheduled or triggered job; in this test the AWS run took between 9 and 11 minutes, including environment setup and the resolution job. A real-time entity resolution API such as Tilores links and deduplicates each record as it is inserted, with the matching itself taking only a few milliseconds, so records can be searched simultaneously as data arrives. Batch matching suits periodic, scheduled deduplication.
- Does AWS Entity Resolution support real-time matching?
- At the time of this hands-on test it did not — AWS Entity Resolution ran as a batch service. As of June 2025 AWS added near-real-time matching that returns a match ID "within seconds" via the Generate Match ID API, though AWS notes near-real-time is not available for advanced rule-based fuzzy matching. Tilores matches each record at insertion in milliseconds, fuzzy matching included.
- AWS Entity Resolution vs Tilores: which matched the test data more accurately?
- On 10 unnormalized records that should resolve to 4 clusters, AWS machine-learning matching produced zero matches (10 separate entities) and AWS rule-based matching produced 7 entities, while Tilores resolved the records to the correct 4 entities with no additional fine-tuning.
- Can Tilores run inside my own AWS account?
- Yes. Tilores can be deployed into a customer's AWS account or used as a SaaS service, and it is available on the AWS Marketplace. This comparison used the public SaaS service's UI.
- What changed in AWS Entity Resolution since this comparison?
- Since this test, AWS added near-real-time matching (June 2025), incremental machine-learning matching workflows (2026), and data-service-provider matching to third-party IDs such as Ramp ID, TruAudience and UID2.0. The original walkthrough reflects the batch-only launch version of the service.
Ready to try entity resolution?
Start Building Free →