10 Core Data Expert Interview Questions and Answers for ios engineers

flat art illustration of a ios engineer

1. Can you explain the difference between NSFetchedResultsController and NSFetchedResultsControllerDelegate?

NSFetchedResultsController is a class responsible for managing and combining the results of a Core Data fetch request with table or collection view UI elements. It is an extremely useful tool when handling large datasets as it only retrieves the data that is currently needed by the user. On the other hand, NSFetchedResultsControllerDelegate is a protocol that is used to monitor and respond to events that occur during the fetch result changes.

The main difference between NSFetchedResultsController and NSFetchedResultsControllerDelegate is that the former manages the results of the fetch and provides data to the UI elements while the latter provides a mechanism for monitoring and responding to changes in that data. In other words, NSFetchedResultsController is the tool that retrieves the data and NSFetchedResultsControllerDelegate is the tool that helps monitor and detect changes to the data.

For example, suppose we have an iOS app that displays a list of all the users who have placed an order in the last week. We can use NSFetchedResultsController to retrieve this data from the Core Data store and then use NSFetchedResultsControllerDelegate to monitor any changes to the retrieved data. If a new order is placed or an existing order is modified or deleted, the delegate will detect these changes and give you the opportunity to update your UI accordingly.

Overall, both NSFetchedResultsController and NSFetchedResultsControllerDelegate are powerful tools that can help manage and monitor changes to Core Data fetch results. Understanding their differences and how they work together can go a long way in creating robust, high-performance applications.

2. What is NSCoder?

NSCoder is a protocol in Swift that's responsible for encoding and decoding data classes, structs, and other objects. It allows Swift to convert objects and other data types into a format that can be stored in a file or transferred over a network.

It's commonly used in iOS development for saving user preferences and app data. For example, if an app allows a user to save their favorite music tracks, NSCoder can be used to store this information locally on the user's device, so that it can be brought up again the next time the app is launched.

NSCoder also plays a key role in networking applications. When data is sent from one device to another over a network, it needs to be encoded into a format that can be transferred over the wire. NSCoder can encode the data into a binary format to make it transferable. After receiving the data on the other device, the NSCoder can decode it back into the original data structure.

Overall, NSCoder is an essential tool for Swift developers who need to encode and decode data as part of their app's functionality.

3. What is NSFetchedPropertyDescription and how would you use it?

NSFetchedPropertyDescription is a subclass of NSPropertyDescription which defines properties fetched as part of a fetch request or as part of the content of an object relationship fault. It allows you to define a property that fetches its value based on a fetch request. In simple terms, it provides the ability to fetch additional data lazily.

For example, imagine an app that has a list of employees and their departments. You may have a department entity and an employee entity, with a to-many relationship from department to employee. If you want to display the number of employees for each department, you could use an NSFetchedPropertyDescription to count the number of employees in each department:

  1. Create the NSFetchedPropertyDescription with a name, entity name, and fetch request.
  2. The fetch request should fetch the employee entities with a predicate that filters by the department.
  3. Set the result type to 'integer' for the number of employees.
  4. Add the NSFetchedPropertyDescription to the department entity.
  5. Now, when you fetch a list of departments, each department object will also include the number of employees.

Using an NSFetchedPropertyDescription can save time and memory by lazily fetching additional data only when needed. It also allows you to aggregate data across relationships, which can be useful for generating reports or statistics.

4. Could you describe the benefits of using parent-child contexts in Core Data?

Parent-Child Contexts in Core Data have multiple benefits, such as:

  1. Concurrency: Parent-Child Contexts allow for concurrency because they enable multi-threading. As a result, this improves the app's performance by reducing the loading times for large data sets. For instance, in our last project, we used Parent-Child Contexts to load and save data in our app. We tested the loading time for 10,000 records without Parent-Child Contexts and with Parent-Child Contexts. With Parent-Child Contexts, loading time was reduced by 40 percent, which is a significant improvement.

  2. Memory management: Another benefit of using Parent-Child Contexts is that they improve memory management. Since Child Contexts are created with their own private queue, they can consume a smaller amount of memory, unlike the Parent Context, which may need to load the entire data set into memory. Thus, if you're working on an app with a large data set, using Parent-Child Contexts is the best way to manage memory usage effectively.

  3. Undo management: Parent-Child Contexts provide good support for undo management since Child Contexts can easily create their own undo stack. This means that each child context can track changes individually and undo/redo them independently. Besides, a parent context is the topmost level for undo management, keeping track of the changes made across all child contexts. Thus, it's quite easy to undo/redo changes and avoid losing vital data in critical scenarios.

5. Can you explain the difference between concurrency types (NSManagedObjectContextConcurrencyType)?

Concurrency types in NSManagedObjectContextConcurrencyType refer to how concurrent access to the managed object context is managed. The three types of concurrency are:

  1. MainQueueConcurrencyType: This concurrency type is used when the managed object context is being used on the main thread. The context is safe to be used on the main thread only, and all the managed objects are executed in the main thread. This means that accessing and changing objects from other threads will lead to a crash.
  2. PrivateQueueConcurrencyType: This concurrency type creates a separate queue on which the managed object context runs. This makes it safe to access the context from multiple threads. Changes in the context are saved using the performBlockAndWait or performBlock methods, which ensures that the changes are performed atomically.
  3. ConfinementConcurrencyType: This concurrency type assumes that the context will only be used in a single thread. This is the default concurrency type for the NSManagedObjectContext. Changes on the context are saved using the save method, and accessing the context from multiple threads or queues could lead to data corruption or crashes.

Understanding concurrency types is important as it ensures that the managed object context is used efficiently and without any risk of data corruption. Using the right concurrency type can also improve app performance, reduce the chances of crashes, and result in more consistent results when accessing data.

6. Can you provide an example of how you would use NSIncrementalStore?

NSIncrementalStore is used for integrating Core Data with external data sources. An example of how I would use it is to build a custom incremental store that connects to an API that provides external data.

First, I would create a subclass of NSIncrementalStore and implement the required methods for retrieving and saving data. Next, I would define a mapping between the API’s data schema and my Core Data model. This mapping would allow me to fetch data from the API and store it in the local Core Data store.

As updates are made to the external data source, NSIncrementalStore would be responsible for fetching only the changes and updating the local Core Data store accordingly. This would allow for efficient synchronization of data between the external data source and the local Core Data store.

To demonstrate the effectiveness of this approach, I would set up a performance test where I would compare the sync times between using this custom NSIncrementalStore with directly retrieving data from the external API. I would expect to see a significant improvement in sync times by utilizing NSIncrementalStore's incremental data fetching capabilities.

7. Could you describe the role of NSPersistentStore and the different types that are available?

NSPersistentStore is a class that implements the physical storage model for core data. This class is responsible for loading and saving data to disk, and it also provides a bridge to different types of persistent stores. There are three types of NSPersistentStores available:

  1. In-Memory store: Data is stored in memory and it is not persisted between launches of the application. This store is useful for temporary data or for cases when data needs to be frequently updated.
  2. Binary store: Data is stored in binary format on disk. This type of store is usually used when performance is a concern or the application needs to load and save large amounts of data.
  3. SQLite store: Data is stored in an SQLite database on disk. This type of store is the recommended storage option for applications because of its performance and scalability.

When choosing which type of store to use, it is important to consider the size and complexity of the data being stored, the performance requirements, and the resources available on the device. In my previous project, we needed to store a large amount of data in a performant and scalable way. We ultimately chose to use the SQLite store and used indexing and caching techniques to optimize the performance of our queries. As a result, we were able to reduce query times by over 50% compared to our previous implementation.

8. Can you provide an example of how you would set up a relationship between entities?

Setting up relationships between entities is a critical aspect of database design. One example of how I would set up a relationship between entities is illustrated below:

  1. I would identify the two entities that need to be related. In this scenario, let's say the two entities are "customer" and "order".

  2. Next, I would determine the type of relationship between the entities. In this case, let's say it's a one-to-many relationship, where a customer can place many orders.

  3. Then, I would create a foreign key in the "order" table that references the primary key of the "customer" table. This would establish the relationship between the two tables.

  4. Finally, I would test the relationship and make sure it is functioning properly. For example, I could run a query to retrieve all orders placed by a particular customer, and make sure the results returned were accurate.

By following the above steps, I would be able to set up a relationship between entities in a way that ensures data integrity and consistency, and allows for efficient retrieval and manipulation of data.

9. Can you explain the difference between NSManagedObjectModel and NSManagedObject?

NSManagedObjectModel and NSManagedObject are two essential frameworks in Core Data development. While they have distinct functionalities, they are interdependent on each other to make Core Data work.

  1. NSManagedObjectModel: NSManagedObjectModel is a blueprint of an object model that defines the attributes, relationships, and operations of entities. It contains a set of entities, their properties, and the associations between them. It acts as a bridge between the Core Data stack and the data model.
  2. NSManagedObject:NSManagedObject, on the other hand, is a data object that represents a single object instance in a Core Data application. It is an instance of an entity in the object model. NSManagedObject class can persist its data to a store (database) and can handle life cycle events such as validation, faulting, and undo/redo management.

Let's say we have an entity called "Employee" and have attributes such as "name," "age," and "salary." We need an NSManagedObjectModel to define this entity, its attributes, and the relationships with other entities, if any.

To create a new instance of the entity "Employee," we will use the NSManagedObject class. It helps us create a new instance of the entity, assign values to its attributes, and use those instances to create relationships with other entities.

So, in summary, NSManagedObjectModel creates an object model that defines the attributes and relationships between entities, whereas NSManagedObject represents a specific instance of an entity in the object model.

10. Could you describe the benefits and limitations of using Core Data versus other local storage solutions, such as Realm or SQLite?

Core Data is an open-source framework that provides an interface to manage the data model for iOS and macOS applications. It comes with several benefits and limitations when compared to other local storage solutions such as Realm and SQLite.

  1. Benefits of Core Data:
    • Performance: Core Data provides optimal performance as it can automatically handle the fetching and caching of the data, which can significantly reduce the time to access data from the database.
    • Data Model: Core Data allows developers to easily create a data model using the graphical interface, which can be further edited to add more entities or relationships between them. This saves a significant amount of time compared to coding data models by hand in other solutions.
    • Persistence: Core Data provides persistence of data, which means that data is automatically saved to the local storage when the application is closed or crashes. This ensures that data is not lost, and the user can resume from where they left off.
  2. Limitations of Core Data:
    • Learning curve: Core Data has a steeper learning curve compared to other solutions as it requires developers to understand the concept of the data model, fetch requests, and relationships between entities to use it effectively.
    • Concurrency: Core Data can be difficult to use effectively in multi-threaded environments, as it requires developers to manage multiple contexts and thread-safe access to the data.
    • Large datasets: Core Data may not be suitable for handling large datasets as it may cause performance issues or memory constraints on devices with limited resources. In such cases, other solutions like Realm or SQLite may be more appropriate.
  3. Benefits of other local storage solutions:
    • Realm: Realm is a database solution that is specifically designed for mobile platforms, with built-in support for objects, queries, and relationships. It offers high performance, cross-platform support, and a simple API for developers to use.
    • SQLite: SQLite is a lightweight, open-source database solution that is widely used for managing data in mobile applications. It offers high performance, reliability, and a wide range of features that are suitable for applications with complex data models.

Overall, the choice of a local storage solution depends on various factors such as the data model complexity, performance requirements, and developer experience. Core Data offers a powerful solution for managing data models in iOS and macOS applications, but other solutions like Realm or SQLite may be more suitable for specific use cases.


Congratulations on making it through these 10 Core Data Expert interview questions and answers for 2023. If you want to take the next steps towards landing your dream remote job as an iOS Engineer, there are a few things you could do to stand out. First, don't forget to write a fantastic cover letter that showcases your skills and experiences. Check out our guide to writing a killer cover letter for iOS Engineers for more tips and tricks. Secondly, make sure your CV is top-notch and effectively communicates your expertise. Use our guide to writing a resume for ios engineers as a resource. Finally, if you're on the lookout for a new remote job as an iOS Developer, be sure to check out Remote Rocketship’s job board for remote iOS Developer positions. We have some amazing opportunities available that may be a perfect fit for you. Good luck in your job search!

Looking for a remote tech job? Search our job board for 25,000+ remote jobs
Search Remote Jobs
Built by Lior Neu-ner. I'd love to hear your feedback — Get in touch via DM or lior@remoterocketship.com