In NoSQL, the database stops checking your data and the developer takes over
A relational database rejects a record that breaks its rules; a NoSQL database typically does not, and checking the data falls to whoever writes the code. Heather Maga, a software developer who teaches database systems at Loyalist College, explains what that trade buys in flexibility and scaling. The harder question she tackles: when should related data live inside one document, and when should it be linked?
Learn the four NoSQL types and a checklist for choosing between embedding and referencing data
Heather Maga gives a no-code, beginner overview of NoSQL databases: what schemaless means, the four main types and how they compare with relational schemas. She explains how to decide between embedding and referencing related data, and why scalability, cost, flexibility and availability lead teams to adopt NoSQL.
“So, NoSQL, very briefly, is a database that does not use SQL to access the data stored within it.”
“So, it's up to the developer in the front end to make sure that the required information is saved into the database in the correct format.”
What you will learn
Distinguish a fixed relational schema from a schemaless NoSQL design and know who enforces the data rules in each.
Identify the four main NoSQL types: key-value, document, column and graph.
Decide when to embed related data and when to reference it, based on access patterns, relationship type and change frequency.
Weigh scalability, cost, flexibility and availability when considering a move to NoSQL.
Spot two common starting points: new projects expecting rapid growth and NoSQL layers that serve APIs over legacy relational databases.
Details
Level
Beginner
Format
Talk
Technical depth
Introductory technical
For
Student, Early career, Career changer
Length
37:53
Published
July 2020
Questions this talk answers
What is a NoSQL database?
It is a database that does not use SQL to access its data and is schemaless, so its structure can change over time and documents can have different attributes.
What are the main types of NoSQL databases?
There are four main types: key-value, document, column and graph databases.
When should related data be embedded and when should it be referenced?
Embed data that is queried together, weak entities such as invoice line items, and one-to-one or one-to-few relationships. Reference for one-to-many and many-to-many relationships, entities that change at different frequencies or are not queried together, and entities used by many others.
Why would an organization consider moving to NoSQL?
Growing data and user volumes slow response times and put availability at risk on a single server. NoSQL scales out across servers, many major options are open source, attributes are easy to add, and a cluster keeps running if one server fails.
Who is responsible for data integrity in a NoSQL database?
For data going in, the responsibility lies with the software, meaning the programmer or developer who writes the data to the database.
About this talk
No code! No deep-dives. This talk will be a basic overview for people that do not have experience with NoSQL databases. I will cover general information about what NoSQL is, how it fits into modern development, and how it compares to traditional relational database schemas.
I won't be going into specifics but instead, be giving you the jump start you need to explore the concepts further on your own. This means you do not need any prior knowledge of NoSQL but it would be useful to have some knowledge of traditional relational databases.
Why adding a column hurts relational databases (68 s)
Welcome to the session entitled What is NoSQL? My name is Heather Maga and I'm going to be presenting a very high level overview of NoSQL. I hope you enjoy it. I'm going to hide the chat again just so that I can keep on track. I have a tendency as my students will tell you to get off track if I don't know.
Don't focus. So, put your questions in the chat if you have any and I've left a little bit of time at the end of the talk today and hopefully if I can answer your questions, I will. Okay. So, first off, who am I? Well, as I said, my name is Heather Maga. I'm a freelance software developer and part-time professor or instructor at a local community college here in Ontario, Canada.
I started my journey into technology about 20 years ago. Sometimes I like to call it falling in love with computers. I know that sounds a little flowery, but sometimes that's how it feels because I kind of came late to it. But I like to tell a little story about how I got into computers. I was updating my mother's computer. She was using Windows 3.1 and updating to Windows 95. Yes, I'm that old. And I was shoving disk after disk after disk into the computer. And where most people would say, this is terrible. Get me out of here. This is boring.
This is boring. I was actually having a lot of fun. So, I thought, you know what, maybe I should do this and go to college for this. So, as I was moving out to Ontario anyway, I applied to Loyalist College. And while I waited to get in, I taught myself web development. And this, of course, was back in the day when we used text editors and tables to lay out our web pages for any of those web developers in the audience today.
So, in 1999, I graduated from Loyalist College with an information systems diploma, which is just another way to say programmer analyst. And I actually work now at Loyalist. Again, I've worked there various times, but I work there right now as a part-time professor. And I teach database systems one and two. I co-teach machine connectivity. And I also teach customer service and project management in our networking courses.
So, it's a lot of fun. My students like to make fun of me a little bit because I kind of lose track of where I'm going, but hopefully I won't lose track too much here. Okay. So, sorry, lost track of my stuff here. Okay. So, I'm also an empty nester. My daughter is also a software developer and she's working in the industry right now.
So, I couldn't be prouder that my little girl is following in my footsteps. So, that's enough about me and all that stuff. Let's talk about NoSQL. So, I'm not sure what everybody's level is, but this is just an overview, very general information. So, we won't be doing any deep dives into anything. So, I'm going to talk a little bit about the basics first.
So, essentially, what is NoSQL? So, NoSQL, very briefly, is a database that does not use SQL to access the data stored within it. And unlike traditional databases, which have a schema and use SQL to get the data out, NoSQL is schemaless. So, what is a schema and what is schemaless? So, a schema is what most relational databases have, which is a predefined structure, which is usually fixed.
It tells us what the tables are, what the columns are, how those tables interact with each other, how the columns store data. They even have information about the keys and the rules that are associated with the data. So, whether they can be blank, what the structure is, and if they're required or not. Whereas schemaless does not necessarily have a predefined structure, and if it does, it can be molded and has a greater flexibility for change later on, because documents can have different attributes.
So, I talked about the schema systems and the relational databases needing rules for things that are required. With no SQL databases, with no SQL databases, the developers check the requirements. So, it's up to the developer in the front end to make sure that the required information is saved into the database in the correct format. So, this doesn't mean that we can't still have relations within our data.
Relations can be made through embedded data or, like with more traditional, we can have referencing. We can also use a combination of the two. So, it is a best practice to still use data modeling to plan out your no SQL databases. But before we have a closer look at embedding, referencing, and modeling, I actually want to talk about the four main flavors or types of no SQL databases.
Okay. So, like I said, there's four different types. There is a key value pair, document, column, and graph. A key value pair is exactly what it sounds like. So, if you have knowledge of databases or programming, you know what key value pairs are. They're made up of keys and values. They don't have a schema and they're very similar to a dictionary or a hash table.
So, keys, just in case, are identifiers associated with values. They must be unique for the entire namespace. And a namespace is an entire collection of identifiers. So, that namespace could be the entire database. However, it could be separate namespaces within a single database. So, values, we should know what they are. But their values are data stored along with the keys.
Values can be simple or complex. So, for example, they can be a string or a binary. And values can vary in type. So, for example, if we have a record, an attribute that is a student picture, a student ID picture, we can actually have one instance of that have a blob, which is a binary object. And then we can have another instance for another student that is a string location on the internet or on the server.
So, they can vary in type within the same attribute. So, you can see where already we have that flexibility that we're going to talk about later, but we are starting to see that flexibility that no SQL databases allow us to have. So, key value databases typically do not enforce checks on data type. And the reason for that is what I just said.
So, values can vary in type. So, the database management system is not enforcing that data type itself. Again, it's up to the developer of the software or the site or to vary in type. How's my speed? Am I talking too fast? Everybody okay? Okay. Great. Thanks, guys. So, carrying on. We have a couple of examples. So, we have, I don't know how well we can see those, but let's just have a zoom in here at the phone directory.
So, this is key value and we can see that the key in this case is Bob Smith and the value is the phone number. So, that's a very simple example of key value. So, let's have a look at the other one. And here we just have just a little bit more complex, but not so much so that we don't understand what's going on.
And these are teacher colon name, teacher one colon school, et cetera. And we see that we have named school availability hours for me and name and school only for Tommy teacher. So, you'll see most of my examples are school based as I have used some of my media that I use for my students in my slides today.
So, you're going to see a lot of school based examples. Okay, so let's talk about document databases, which are my favorite. If you can have a favorite kind of database, which I do. So, document databases use a key value approach, but they store the values as documents. So, documents don't refer to something that we would identify initially as a document.
So, it's not a word processing file, but rather data structures are stored as strings or representations of strings. So, typically that is in the form of JSON or XML. So, JSON JavaScript object notation and XML extensible markup language. So, I focus mostly on JSON and the examples that we're going to see are JSON. But some people feel more comfortable with XML, but they can be either one.
So, instead of storing each attribute of an entity within a separate key, document databases store multiple attributes in a single document. So, the example that I have here on the screen is two students, Joe and Sally, and we can see that they have documents. We have Joe and he has key value pairs within his document. Sally also has key value pairs within her document.
But we notice something different here is that we have extra attributes for Sally. Now, that doesn't mean that Joe doesn't have those attributes. It just means that Sally does have them. If this were a traditional relational database structure, we would have to see those columns over here and they would typically have default or null values within them or blank.
So, again, we're starting to see that flexibility where we can add these attributes as we go and we don't have to store them if they don't have them. So, I'm going to talk very, very briefly about column and graph databases. I don't have much experience with them, so I can't really explain them as well as I would want to.
So, I'll just talk about them briefly. A column database is a NoSQL database that stores data in columns instead of rows. They take up typically less space than a relational database and are faster because of the way that it indexes data. So, column and graph databases are a lot more complex than our simple key value and document databases.
And really, you could do a whole session or a whole presentation or a whole lecture or, you know, even a whole course on these types alone. So, that's why I'm just going to go lightly into these. So, a graph database, it uses structures called nodes and relationships. And if you're familiar with object-oriented programming, you know that a node or you know that an object is a class.
And so, a node is an object that has an identifier and a set of attributes. That's very similar to a class. And a relationship is a link between the nodes that contains also an attribute about that relation. So, early I talked about the structure of NoSQL databases or rather NoSQL databases having a predefined structure. But the reality is that they do have a start structure.
It's just that it's a lot more flexible. We know that when we build a relational database, we're taking a lot more time in the beginning or we should be taking a lot more time in the beginning to plan out our database and really understand the relationships and doing, you know, normalization and making sure that our database is as efficient as we can make it.
NoSQL databases usually do start with a structure. And it is important, but we can change those models over time. So, where we start is not necessarily where we end with our documentation or our modeling of our NoSQL databases. So, when we're modeling our NoSQL databases, we first decide on what objects we want to keep track of, just like we would in a relational database.
And we also decide how they're going to interact with each other. One of the important things that we think about when we're talking about NoSQL databases, maybe more specifically document databases is how we're going to be interacting with that data. So, in what context are things being accessed? Are they going on a report? Are they going on some kind of dashboard?
What items are going on a dashboard? And that's so that we know when we're building out our objects, we know what things we can embed and what things we want to reference instead. So, embedding versus referencing. So, I have examples that explain this a lot better on the next slides. But embedding is basically the objects or documents are included within the main parent object.
So, if you have a student document, you're embedding all of their class information within that document. And we'll see an example of that. They typically require less reads to the database. So, we have a better read performance. And that's because if we are loading a dashboard, if we're loading a dashboard with student information and that student is seeing their information and then they also want to see their class information, we're reading one document instead of one document and then all the class for that student.
So, it's less reads. Referencing is more similar to a relational database schema in that objects are linked from the main object. By keys. It has better write performance for obvious reasons. So, this is an example of a document. The student, the example that I just gave, where we have class information embedded with a student. And I'm just going to zoom in here.
A little bit. Okay. So, we have a student here, Phillip Frye, with his student address and his student ID. So, that's a student information. Now, obviously, this is really trimmed down because just to save space and so it all fits nicely on a slide. Obviously, we would have a lot more student information and we would have a lot more class information.
But we can see here that we're actually including the course ID, course name, course room within this student's document. So, again, if we were to read this into a dashboard, we would read this document and we could display all of this information because we already have it all read. So, let me zoom out here. So, if we were to reference this instead, drag this over here a little bit, you can see that we have -- now, these are included in the same file just for viewing.
So, they could be in separate files, obviously. So, the student document, we see it has the student information. But you'll notice now, instead of the complete course information, it's more of a traditional relational database type structure where we are referencing an ID of a course. And then we have the course documents below that have the expanded information.
So, now, if we're using the same example of a dashboard, if that student goes and loads their dashboard, we would have to read the student document and all of the course documents that are related to that student. So, we have some important questions to ask ourselves when we're deciding if we're going to embed or reference. And one of the main examples that I gave was the dashboard and how we're accessing that information.
So, that's one of the questions that we ask ourselves. The next is the relationship between the entities and their attributes. So, we can ask ourselves questions. So, when to reference. So, one-to-many relationships. And if you have experience with databases, you know that a one-to, you know what a one-to-many relationship is. But an example would be a blog post that has many comments or likes.
Another time we would reference instead of embed would be entities are frequently queried or updated or not frequently queried or updated together. So, again, we can go back to our blog post and our comments. Many-to-many relationships. So, for example, students and courses or courses and rooms. The important one is entities change with different frequencies. And we can again use our blog and likes and comments as an example of entities that change with different frequency.
So, comments are related to blog posts, but they would, those documents would change more frequently than the blog post itself. I mean, typically when you write a blog post, it stays there. You might edit it later, but not with the same frequency that comments are being added. One entity is used by many other entities. And the example that I usually give here is classrooms because that entity has a lot of attributes associated with it that other entities are accessing at the same time.
So, when to embed then? We would embed with entities that are typically queried or used together or with weak entities. So, if, for example, we have an invoice or an order that has line items. Those line items are weak entities that only exist if that invoice exists. And they're only ever queried together. We would never really query a line item by itself.
We would use those line items with an invoice. So, in our previous example with the student, if we switch that to orders, we would have the order information and then we would embed the line items for each item ordered right within that document. And it would make loading the order or the invoice or the purchase order or whatever a lot quicker.
Another reason to embed would be a one-to-one relationship or a one-to-few relationship. So, this could be something like a phone number, like a student and a phone number or a user profile, social media accounts. So, of course, many of us know this. Anybody that's online or manages multiple accounts or whatever, we do have more and more social media accounts right now.
But typically, a student or a user account on a website, they would link one Facebook account, one Twitter account, one Instagram account. And they would generally change with the same frequency as well. So, instead of social media accounts or phone numbers, say, we could say emergency contact information. So, if you have a staff document where you have all the staff information, typically when somebody adds that emergency contact information, that's not changed for a long time.
So, and it might be updated as the main staff information is updated. So, if the staff member got divorced, they also changed their emergency contact information, for example. So, just keeping an eye on the time here. So, what would motivate us to look into NoSQL or what would be a catalyst for a change or for that process of wanting to change or wanting to implement some kind of NoSQL?
So, it would be the typical things that happen with databases over time. The volume of data increases over time. And we know that it's 2020 and data is still king, right? So, we know that data is everything nowadays. So, we have more and more data that's being saved and accessed. So, we have volumes and volumes and volumes of data, which increases exponentially in some cases.
All that data means slower response times, especially, even if there's not a large increase in the database size or the amount of data, maybe we have more users. Maybe we have more people accessing the systems. So, we need better response times. And all the volumes of data, all the volumes of users could also mean that the availability could be in jeopardy.
Essentially, if we're talking about old traditional proprietary software based on one database server, if we are having issues with access, if that server goes down, it goes down for everybody. And scaling those relational databases means time, it means money. And we may have invested the time and the money, but the technology may not be up to what we need.
So, we may need something to go so fast that we need a certain type of processor, a certain amount of RAM, or a certain bandwidth for our network, but we don't have that available to us with the current technology. So, we have some main considerations when we're talking about those large scale databases, where it's large scale based on data, large scale based on access.
So, we have to consider things like scalability, cost, flexibility, and availability. So, scalability is important. And the faster we can scale something, the better. So, developers and administrators could choose to scale out or scale up. And if you've ever been in that situation before, you know that you would rather scale out. So, add more servers and have distributed database systems instead of a single server system.
No SQL can easily adjust to that kind of scaling, because it has that kind of built-in technology. Scaling up, of course, is upgrading the existing database server, you know, processors, memory, bandwidth, etc., which I talked about before. And we know that if we scale up, if we're talking about one server, we're talking about taking that server down and not having access to that if we're scaling up.
So, that increase in scalability is something that is key for thinking about using NoSQL databases. Cost is another one. If we have any analysts that are thinking about money or owners, business owners, even developers that are in charge of deciding on technology to use. A lot of times, we have a concern with licensing. We all know that the cost of licensing some of the relational databases can be quite large.
So, it might be based on things like the size of the server. So, how much data, the number of users, the number of authorized users or administrators. But with many major NoSQL databases, they are open source. So, that initial access, that initial foothold that we can make, that initial foray that we can make into that NoSQL space is a little bit easier because we don't have to invest a lot of money for licensing.
That doesn't mean that there's no support because most NoSQL database server management systems have support packages. Sorry, I lost my train of thought. Support packages or contracts so that if you do get lost in that forest, you can still have that little lifeline to help you out through paid support if you need it. So, flexibility. And I talked about this a lot.
And flexibility is very important. So, NoSQL databases do not require a fixed database structure or schema. So, I talked about that already. So, we know that in a relational database, you typically need to know all the data you will need to keep track of when you start developing that database. So, there's a lot more pre-planning. We should be pre-planning anyway, but there's a lot of that pre-planning.
And if we have to add attributes or columns later, if anybody has ever done that before, we know that what a giant problem that is to simply add a column or the dirty data that can happen from adding a column and trying to access old and new records and not getting the proper results in reports. And it's something that I saw a lot, you know, within the school and other companies that I worked for, there's always that older data that kind of gets lost because of something that we've had to update.
Whereas, if we're using NoSQL, attributes are easily added. Boy, I am running behind. Okay. So, availability. NoSQL databases can be more available as the situation arises where a server goes down. Another server in the cluster can take over without any downtime for website or software systems. And I'm, I had a whole section about distributed databases, but it's a good thing I left it out because we're getting pretty close to 35 minutes here.
So, yeah, so we all know that if we have a distributed database and even a simple cluster of computers, say five or 10 computers, we know if one of those goes down, we still have access to the rest of the cluster. So, that makes it more available than our single server system at the very least. So, we have a couple of typical implementations and then I'm going to have to wrap it up here.
But, you might be looking at NoSQL for a new software project or a new development where you're projecting a rapid growth, whether it's users or data. So, it might be something that you're thinking of and it's a good place to start. Or, the other thing that is popular is when you're modernizing your relational databases and you're creating APIs, you're creating all these new tools for your users.
What you can actually do is create a NoSQL database that's either static or dynamic that your APIs access instead of accessing that relational database. So, that makes the availability, sorry, and the speed better than having to access that relational database because we can access that static file. So, the consistency might not be there because the data is not updated in an instant.
It's updated on a schedule. But, it's still a good way to modernize your old proprietary software, your old relational databases, SQL and creating some APIs. Okay, that's all that I have. I actually, I did actually have a lot more. So, I'm glad I kind of knew where to cut it there. But, if there's questions, definitely leave them in there.
We only have a couple of minutes. But, if you have some questions, definitely leave them in there. If I can't answer them or I don't get to them, definitely connect with me on LinkedIn. Or, you can visit my personal website or, obviously, the Women Tech Slack chat. So, let me just see if I can open this up here.
Okay, Victoria, what workspace do we need to create NoSQL DB in? So, what software is there? You can create a NoSQL database on any kind of traditional environment. So, in my class, we use CouchDB. There's also MongoDB. I believe that Microsoft and Amazon both have NoSQL offerings. So, you can kind of have a workspace that's local, on your server, in the cloud.
It's rapidly expanding, as far as I know. And there's something else here. I don't know how to work this panel here. But, okay. So, I think we have to wrap it up, unless there's other questions. I see there's still a lot of people viewing. So, was there another question? No? Okay. Well, thank you, everybody, for watching. Hopefully, I didn't go too fast for everybody.
I know it was kind of basic. Oh, I wish I could answer that one. But, there's not enough time to answer the data integrity with NoSQL. But, very briefly, the data integrity for data going in is the responsibility of the actual software. So, the programmer or the developer that's putting that data in the database. The responsibility lies there.
And then, if you're talking about distributed, that's a whole other conversation. Sorry, I couldn't give that more attention. But, definitely connect with me later. Okay. That's it. Thank you very much, everyone.
Transcribed automatically; names checked against the speaker record. Select a time to jump there.
Article based on this talk
How NoSQL differs from relational databases, and when to embed or reference your data
Heather Maga's no-code primer covers schemaless design, the four NoSQL types and a practical checklist for modeling related data.
In short
NoSQL databases drop SQL and the fixed schema. In exchange, teams get flexibility, easier scaling and often lower licensing costs. In this beginner overview, software developer and college instructor Heather Maga explains the four main NoSQL types and gives a practical checklist for a core design choice: whether to embed related data inside a document or reference it by key. Her message is that NoSQL still needs planning, just a more forgiving kind.
Key takeaways
Distinguish a fixed relational schema from a schemaless NoSQL design and know who enforces the data rules in each.
Identify the four main NoSQL types: key-value, document, column and graph.
Decide when to embed related data and when to reference it, based on access patterns, relationship type and change frequency.
Weigh scalability, cost, flexibility and availability when considering a move to NoSQL.
Spot two common starting points: new projects expecting rapid growth and NoSQL layers that serve APIs over legacy relational databases.
Schema versus schemaless
Maga, who teaches database systems at Loyalist College in Ontario, starts with a plain definition: "So, NoSQL, very briefly, is a database that does not use SQL to access the data stored within it." (4:16)
A relational schema is a predefined and usually fixed structure. It describes the tables and columns, how tables relate, which keys exist, and the rules for each field, such as whether it may be blank or is required. A schemaless database does not necessarily have that structure up front. When it does, the structure can be reshaped later, because individual documents can carry different attributes.
That flexibility moves responsibility. In a NoSQL system, the database is not the gatekeeper for required fields or formats: "So, it's up to the developer in the front end to make sure that the required information is saved into the database in the correct format." (5:40) Relationships between data do not disappear either. They are expressed through embedded data, references, or both, and Maga stresses that data modeling remains a best practice.
Four flavours of NoSQL
Maga walks through the four main types, mostly with school examples taken from her own teaching material.
Key-value databases work like a dictionary or hash table. Keys must be unique within a namespace, and values can be simple or complex. Values can even vary in type within the same attribute: one student's ID picture might be stored as a binary object while another's is a string pointing to a file location. That is why key-value databases typically do not enforce data types.
Document databases, her favourite, use a key-value approach but store values as documents, usually JSON or XML, holding many attributes in one place. In her example, a student named Sally has extra attributes that another student, Joe, does not, and nothing needs to be stored for Joe to make that work. In a relational table, those columns would sit empty or hold default values. As she puts it: "So, again, we're starting to see that flexibility where we can add these attributes as we go and we don't have to store them if they don't have them." (13:19)
She is open that column and graph databases are outside her main experience, so she covers them briefly. As she describes them, column databases store data in columns instead of rows and typically use less space and run faster because of how they index data. Graph databases are built from nodes, which resemble classes in object-oriented programming, and relationships that link nodes and carry attributes of their own.
Embedding or referencing
NoSQL databases usually do start with a structure, Maga explains, but it is allowed to evolve: "So, where we start is not necessarily where we end with our documentation or our modeling of our NoSQL databases." (15:55) As with relational design, you decide which objects to track and how they interact. The extra question is how the data will be used. Does it feed a report, or a dashboard?
That question drives the choice between embedding and referencing. Embedding puts related documents inside a parent, for example a student document that contains all of that student's course details. Loading the student's dashboard then takes one read, which gives better read performance. Referencing links objects by key, much as a relational database does, and gives better write performance, but a dashboard must read the student document plus every related course document.
Her checklist suggests referencing for one-to-many relationships (a blog post and its comments or likes), entities not usually queried or updated together, many-to-many relationships (students and courses), entities that change at different rates, and entities used by many others, such as classrooms. Embedding fits data that is queried together, one-to-one or one-to-few relationships such as a user's social media accounts or emergency contacts, and weak entities like invoice line items: "We would never really query a line item by itself." (23:10)
Why teams make the move
The trigger is usually familiar: more data, more users, slower responses, and a single server whose failure takes everyone offline. Maga frames the decision around four considerations. On scalability, she favours scaling out over upgrading one machine: "So, add more servers and have distributed database systems instead of a single server system." (28:19) On cost, relational licences can be expensive, while many major NoSQL databases are open source, with paid support available. On flexibility, adding a column to a relational database can create dirty data and broken reports, while NoSQL attributes are easy to add. On availability, another server in a cluster can take over when one fails.
She closes with two typical uses: new projects that expect rapid growth in users or data, and modernizing legacy systems by giving new APIs a static or dynamic NoSQL store to read from instead of the relational database. The trade-off is consistency, since that store is updated on a schedule rather than instantly.
In the Q&A she mentions CouchDB, which she uses in class, MongoDB, and NoSQL offerings from Microsoft and Amazon. On data integrity, she repeats the core point: "So, the programmer or the developer that's putting that data in the database. The responsibility lies there." (37:03)
Watch the talk
"What Is NoSQL?" by Heather Maga, 38 minutes: https://www.womentech.net/video/heather-maga-what-nosql-0
About the speaker
Heather Maga is a Business Owner and Software Developer at Copper Owl Development, her new small business, and a part-time Professor at Loyalist College in Ontario, Canada. She draws on 20 years of experience in mentoring, business and systems analysis, project management, consulting and education.
Questions this talk answers
What is a NoSQL database?
What are the main types of NoSQL databases?
When should related data be embedded and when should it be referenced?
Why would an organization consider moving to NoSQL?
Who is responsible for data integrity in a NoSQL database?
Drafted with AI from the talk transcript. Editor review pending.
Frameworks and ideas mentioned
Embedding versus referencing
Database normalization
Data modeling
Scale out versus scale up
Resources mentioned
CouchDB
MongoDB
Cite this talk
Heather Maga. "What Is NoSQL?." WomenTech Network, 2020. https://www.womentech.net/video/heather-maga-what-nosql-0