{"id":3722,"date":"2026-11-02T09:16:48","date_gmt":"2026-11-02T06:16:48","guid":{"rendered":"https:\/\/niteducation.com\/resources\/?p=3722"},"modified":"2026-11-02T09:16:51","modified_gmt":"2026-11-02T06:16:51","slug":"what-is-a-database","status":"publish","type":"post","link":"https:\/\/niteducation.com\/resources\/what-is-a-database\/","title":{"rendered":"What Is a Database? How Databases Work in Real Applications"},"content":{"rendered":"\n<!--\nNewton Institute of Technology \u2014 Article 215\nMaster Stylesheet v6.3 Premium production body \u2014 1 November 2026\nWordPress supplies the page's only semantic H1. This fragment uses .nit-hero__title instead.\nLoad the locked nit-articles-master-v6.3.css once at site level.\nNo article-specific CSS, inline styles, scripts, new component classes or article images are used.\nCanonical: https:\/\/niteducation.com\/resources\/what-is-a-database\/\nPrimary intent: what is a database; how databases work in real applications.\n-->\n<article class=\"nit-article nit-article--pathway-guide nit-article--software\" itemscope itemtype=\"https:\/\/schema.org\/Article\" aria-labelledby=\"nit-article-title\">\n  <meta itemprop=\"datePublished\" content=\"2026-11-01\">\n  <meta itemprop=\"dateModified\" content=\"2026-11-01\">\n  <meta itemprop=\"inLanguage\" content=\"en-KE\">\n  <meta itemprop=\"author\" content=\"Newton Institute of Technology Editorial Team\">\n\n  <div class=\"nit-pg-hero\" aria-labelledby=\"nit-article-title\">\n    <div>\n      <p class=\"nit-pg-kicker\">Database Fundamentals <span>Beginner Guide<\/span><\/p>\n      <p class=\"nit-hero__title\" id=\"nit-article-title\" itemprop=\"headline\">What Is a Database?<br>How Databases Work in Real Applications<\/p>\n      <p class=\"nit-pg-hero__line\">Frontend <i>\u00b7<\/i> Backend <i>\u00b7<\/i> Database<\/p>\n      <p class=\"nit-pg-hero__summary\" itemprop=\"description\">Follow data from a user&#8217;s screen into a database and back, then learn how tables, keys, queries, constraints, indexes and transactions make real applications work.<\/p>\n      <div class=\"nit-pg-hero__actions\">\n        <a class=\"nit-pg-button nit-pg-button--gold\" href=\"#student-request\">Follow one real request<\/a>\n        <a class=\"nit-pg-button nit-pg-button--outline\" href=\"#design-exercise\">Design a small database<\/a>\n      <\/div>\n    <\/div>\n\n    <div class=\"nit-pg-hero__art\" aria-label=\"Database request and result route\">\n      <p>The data route<\/p>\n      <div class=\"nit-pg-signpost\" aria-hidden=\"true\">\n        <span class=\"nit-pg-signpost__top\">Request<\/span>\n        <span class=\"nit-pg-signpost__centre\">DB<\/span>\n        <span class=\"nit-pg-signpost__bottom\">Result<\/span>\n      <\/div>\n      <strong>Store it. Find it. Return it.<\/strong>\n    <\/div>\n\n    <div class=\"nit-pg-hero__meta\" aria-label=\"Article summary\">\n      <p><span>Focus<\/span>Database fundamentals<\/p>\n      <p><span>Flow<\/span>App \u2192 data \u2192 response<\/p>\n      <p><span>Core ideas<\/span>Tables \u00b7 keys \u00b7 queries<\/p>\n      <p><span>Updated<\/span>1 November 2026<\/p>\n    <\/div>\n  <\/div>\n\n  <div class=\"nit-article__body\">\n    <section class=\"nit-quick-answer\" aria-labelledby=\"quick-answer-title\">\n      <div class=\"nit-quick-answer__head\">\n        <span class=\"nit-quick-answer__mark\" aria-hidden=\"true\">\u2713<\/span>\n        <div>\n          <p class=\"nit-quick-answer__label\">Quick answer<\/p>\n          <p class=\"nit-quick-answer__kicker\" id=\"quick-answer-title\">What is a database?<\/p>\n        <\/div>\n      <\/div>\n      <div class=\"nit-quick-answer__body\">\n        <p class=\"nit-quick-answer__text\"><strong>A database is an organised collection of related data that can be stored, retrieved and managed.<\/strong> A database management system (DBMS) is the software that manages that data. In a real web application, a common flow is <strong>User \u2192 Frontend \u2192 Backend \u2192 Database system \u2192 Backend \u2192 Frontend<\/strong>. <sup><a href=\"#ref-1\">[1]<\/a><\/sup><\/p>\n        <ul class=\"nit-quick-answer__signals\">\n          <li>Store<\/li>\n          <li>Retrieve<\/li>\n          <li>Relate<\/li>\n          <li>Protect<\/li>\n          <li>Return<\/li>\n        <\/ul>\n      <\/div>\n    <\/section>\n\n    <div class=\"nit-facts-grid nit-software-facts\" aria-label=\"Database fundamentals at a glance\">\n      <div class=\"nit-fact-card\"><span>Database<\/span><strong>Organised data<\/strong><\/div>\n      <div class=\"nit-fact-card\"><span>DBMS<\/span><strong>Management software<\/strong><\/div>\n      <div class=\"nit-fact-card\"><span>Table<\/span><strong>Rows + columns<\/strong><\/div>\n      <div class=\"nit-fact-card\"><span>Key<\/span><strong>Identity + relationships<\/strong><\/div>\n      <div class=\"nit-fact-card\"><span>Query<\/span><strong>Ask for data<\/strong><\/div>\n      <div class=\"nit-fact-card\"><span>Transaction<\/span><strong>All or nothing<\/strong><\/div>\n    <\/div>\n\n    <nav class=\"nit-toc\" aria-labelledby=\"toc-title\">\n      <h2 id=\"toc-title\">On this page<\/h2>\n      <ol>\n        <li><a href=\"#why-database\">Why applications need databases<\/a><\/li>\n        <li><a href=\"#student-request\">Follow one student-results request<\/a><\/li>\n        <li><a href=\"#relational-structure\">Tables, rows, columns and keys<\/a><\/li>\n        <li><a href=\"#relationships\">Relationships and data modelling<\/a><\/li>\n        <li><a href=\"#inside-dbms\">What happens inside a DBMS<\/a><\/li>\n        <li><a href=\"#data-rules\">Constraints and data integrity<\/a><\/li>\n        <li><a href=\"#transactions\">CRUD and transactions<\/a><\/li>\n        <li><a href=\"#concurrency\">When two users act at once<\/a><\/li>\n        <li><a href=\"#comparisons\">Database comparisons beginners confuse<\/a><\/li>\n        <li><a href=\"#database-types\">Main database types<\/a><\/li>\n        <li><a href=\"#security\">Database security basics<\/a><\/li>\n        <li><a href=\"#design-exercise\">Beginner database exercise<\/a><\/li>\n        <li><a href=\"#faq\">Frequently asked questions<\/a><\/li>\n      <\/ol>\n    <\/nav>\n\n    <section class=\"nit-section-panel\" id=\"why-database\">\n      <h2>Why does an application need a database?<\/h2>\n      <p>Suppose you complete an online course-registration form today and return tomorrow. If the application needs to remember your registration, the information must be stored somewhere persistent.<\/p>\n      <p><strong>Persistent data<\/strong> is information that remains available after the current page, session or program ends. A database is one common way to organise that long-lived information.<\/p>\n\n      <div class=\"nit-tech-board\">\n        <article class=\"nit-tech-card\"><h3>School system<\/h3><p>Students, courses, enrolments, examination results, attendance and payments.<\/p><\/article>\n        <article class=\"nit-tech-card\"><h3>Online shop<\/h3><p>Customers, products, prices, stock levels, orders and delivery records.<\/p><\/article>\n        <article class=\"nit-tech-card\"><h3>Booking system<\/h3><p>Users, available slots, bookings, status changes and payment records.<\/p><\/article>\n      <\/div>\n\n      <h3>Why not save everything in one file?<\/h3>\n      <p>A small program can use a CSV, JSON or another ordinary file. That can be perfectly reasonable. The challenge grows when thousands of records, relationships, repeated queries and several simultaneous users must be managed safely.<\/p>\n      <div class=\"nit-callout nit-callout--info\">\n        <p class=\"nit-callout__title\">A useful distinction<\/p>\n        <p><strong>A file stores data.<\/strong> A database system is designed to manage structured data and operations around it\u2014such as queries, relationships, constraints, indexes and transactions. The right choice depends on the problem, not on whether one tool sounds more advanced.<\/p>\n      <\/div>\n    <\/section>\n\n    <section class=\"nit-section-panel\" id=\"student-request\">\n      <h2>Follow one real request: a student checks examination results<\/h2>\n      <p>Imagine Amina opens a school portal and presses <strong>View My Results<\/strong>. The final result may appear in a moment, but several parts of the application cooperate behind that button.<\/p>\n\n      <div class=\"nit-concept-grid\">\n        <article class=\"nit-concept-card\"><h3>1. Frontend<\/h3><p>The browser detects Amina&#8217;s click. It knows the interface needs examination data that is not currently on the screen.<\/p><\/article>\n        <article class=\"nit-concept-card\"><h3>2. Backend<\/h3><p>The frontend sends a request. The backend identifies the signed-in account, checks permission and decides which records are required.<\/p><\/article>\n        <article class=\"nit-concept-card\"><h3>3. Database system<\/h3><p>The backend performs the required database operation. The DBMS finds matching records and returns the result.<\/p><\/article>\n      <\/div>\n\n      <div class=\"nit-code-window\" aria-label=\"Simple SQL query for one student's results\">\n        <div class=\"nit-code-window__bar\">\n          <span class=\"nit-code-window__dot\"><\/span><span class=\"nit-code-window__dot\"><\/span><span class=\"nit-code-window__dot\"><\/span>\n          <span class=\"nit-code-window__file\">results-query.sql<\/span>\n        <\/div>\n        <div class=\"nit-code-window__body\">\n          <span class=\"nit-code-line\"><span class=\"nit-code-keyword\">SELECT<\/span> subject, score<\/span>\n          <span class=\"nit-code-line\"><span class=\"nit-code-keyword\">FROM<\/span> results<\/span>\n          <span class=\"nit-code-line\"><span class=\"nit-code-keyword\">WHERE<\/span> student_id = <span class=\"nit-code-string\">1042<\/span>;<\/span>\n        <\/div>\n      <\/div>\n\n      <p>The purpose of the query here is not to turn this into a SQL tutorial. It simply means: <strong>find the result records belonging to student 1042.<\/strong> NIT&#8217;s separate SQL guide covers querying in more depth. <sup><a href=\"#ref-11\">[11]<\/a><\/sup><\/p>\n\n      <div class=\"nit-table-wrap\">\n        <table class=\"nit-table\">\n          <thead><tr><th scope=\"col\">result_id<\/th><th scope=\"col\">student_id<\/th><th scope=\"col\">subject<\/th><th scope=\"col\">score<\/th><\/tr><\/thead>\n          <tbody>\n            <tr><td>501<\/td><td>1042<\/td><td>Mathematics<\/td><td>78<\/td><\/tr>\n            <tr><td>502<\/td><td>1042<\/td><td>English<\/td><td>71<\/td><\/tr>\n            <tr><td>503<\/td><td>1043<\/td><td>Mathematics<\/td><td>82<\/td><\/tr>\n          <\/tbody>\n        <\/table>\n      <\/div>\n      <p class=\"nit-table-note\">On a phone, swipe the table sideways to view every column.<\/p>\n\n      <ol class=\"nit-checklist\">\n        <li><strong>Amina clicks:<\/strong> the frontend detects the action.<\/li>\n        <li><strong>The request is sent:<\/strong> the backend receives the request.<\/li>\n        <li><strong>Identity and permission are checked:<\/strong> the application decides what Amina may see.<\/li>\n        <li><strong>The database is queried:<\/strong> matching result records are requested.<\/li>\n        <li><strong>The DBMS returns data:<\/strong> Mathematics 78 and English 71 match student 1042.<\/li>\n        <li><strong>The backend prepares the response:<\/strong> only the required information is returned.<\/li>\n        <li><strong>The frontend displays it:<\/strong> the records become a readable results table.<\/li>\n      <\/ol>\n\n      <div class=\"nit-callout nit-callout--success\">\n        <p class=\"nit-callout__title\">The mental model to keep<\/p>\n        <p><strong>User \u2192 Frontend \u2192 Backend\/API \u2192 Database system \u2192 Backend \u2192 Frontend \u2192 User.<\/strong> The database is one layer in a larger application, not the whole application.<\/p>\n      <\/div>\n    <\/section>\n\n    <section class=\"nit-section-panel\" id=\"relational-structure\">\n      <h2>How does a relational database organise information?<\/h2>\n      <p>A relational database organises information in tables. Each table consists of rows and columns, and each column has a data type that limits and gives meaning to the values it can contain. <sup><a href=\"#ref-2\">[2]<\/a><\/sup><\/p>\n\n      <div class=\"nit-table-wrap\">\n        <table class=\"nit-table\">\n          <thead><tr><th scope=\"col\">student_id<\/th><th scope=\"col\">student_name<\/th><th scope=\"col\">phone<\/th><\/tr><\/thead>\n          <tbody><tr><td>101<\/td><td>Amina<\/td><td>0712 345 678<\/td><\/tr><tr><td>102<\/td><td>Brian<\/td><td>0700 123 456<\/td><\/tr><\/tbody>\n        <\/table>\n      <\/div>\n\n      <div class=\"nit-tech-board\">\n        <article class=\"nit-tech-card\"><h3>Table<\/h3><p>A structured collection of one kind of related record, such as <code>students<\/code> or <code>payments<\/code>.<\/p><\/article>\n        <article class=\"nit-tech-card\"><h3>Row<\/h3><p>One record. In the table above, the row beginning with <code>101<\/code> represents Amina.<\/p><\/article>\n        <article class=\"nit-tech-card\"><h3>Column<\/h3><p>One defined property, such as <code>student_name<\/code>, <code>phone<\/code> or a date.<\/p><\/article>\n        <article class=\"nit-tech-card\"><h3>Data type<\/h3><p>The allowed kind of value, such as integer, numeric, text, date or timestamp. <sup><a href=\"#ref-2\">[2]<\/a><\/sup><\/p><\/article>\n        <article class=\"nit-tech-card\"><h3>Primary key<\/h3><p>A column or set of columns used to identify each row uniquely.<\/p><\/article>\n        <article class=\"nit-tech-card\"><h3>Schema<\/h3><p>The defined structure of the database: tables, columns, data types, relationships and rules.<\/p><\/article>\n      <\/div>\n\n      <h3>Why use an ID instead of a person&#8217;s name?<\/h3>\n      <p>Two students can share the same name. Their database records still need to remain distinct.<\/p>\n      <div class=\"nit-table-wrap\">\n        <table class=\"nit-table\"><thead><tr><th scope=\"col\">student_id<\/th><th scope=\"col\">student_name<\/th><\/tr><\/thead><tbody><tr><td>102<\/td><td>Brian Otieno<\/td><\/tr><tr><td>587<\/td><td>Brian Otieno<\/td><\/tr><\/tbody><\/table>\n      <\/div>\n      <p>A primary key provides a reliable row identifier. PostgreSQL&#8217;s documentation describes primary-key values as unique and non-null. <sup><a href=\"#ref-3\">[3]<\/a><\/sup><\/p>\n      <div class=\"nit-callout nit-callout--info\"><p class=\"nit-callout__title\">Beginner rule<\/p><p><strong>Names describe people. IDs identify records.<\/strong><\/p><\/div>\n    <\/section>\n\n    <section class=\"nit-section-panel\" id=\"relationships\">\n      <h2>How do database tables connect?<\/h2>\n      <p>A real school system might have separate tables for students, courses, enrolments, payments and results. Relationships connect those records without copying the same information everywhere.<\/p>\n\n      <div class=\"nit-table-wrap\">\n        <table class=\"nit-table\">\n          <thead><tr><th scope=\"col\">payment_id<\/th><th scope=\"col\">student_id<\/th><th scope=\"col\">amount<\/th><\/tr><\/thead>\n          <tbody><tr><td>7001<\/td><td>101<\/td><td>KSh 10,000<\/td><\/tr><tr><td>7002<\/td><td>101<\/td><td>KSh 8,000<\/td><\/tr><tr><td>7003<\/td><td>102<\/td><td>KSh 15,000<\/td><\/tr><\/tbody>\n        <\/table>\n      <\/div>\n      <p>The repeated value <code>student_id = 101<\/code> links two payment records to Amina. This creates a <strong>one-to-many relationship<\/strong>: one student can have many payments.<\/p>\n      <p>A foreign-key constraint can require a referenced parent record to exist, helping preserve referential integrity. <sup><a href=\"#ref-3\">[3]<\/a><\/sup><\/p>\n\n      <h3>Why not put everything in one huge table?<\/h3>\n      <p>A single table with <em>Payment 1, Payment 2, Payment 3, Result 1, Result 2<\/em> looks simple only until the real system changes. A learner may make a fourth payment, take another course or accumulate more results. Separating real-world entities into related tables gives the data a structure that can grow.<\/p>\n\n      <h3>Turn a real-world sentence into a database model<\/h3>\n      <div class=\"nit-project-grid\">\n        <article class=\"nit-project-card\" data-project=\"01\"><h3>Identify the things<\/h3><p>\u201cA student can enrol in a course.\u201d The important entities are <strong>Student<\/strong> and <strong>Course<\/strong>.<\/p><\/article>\n        <article class=\"nit-project-card\" data-project=\"02\"><h3>Identify the relationship<\/h3><p>A course can have many students, and a student may take more than one course over time.<\/p><\/article>\n        <article class=\"nit-project-card\" data-project=\"03\"><h3>Create the bridge<\/h3><p>An <strong>Enrolment<\/strong> record can connect one student record to one course record.<\/p><\/article>\n        <article class=\"nit-project-card\" data-project=\"04\"><h3>Keep each record focused<\/h3><p>The student describes the learner, the course describes the programme, and the enrolment describes the connection.<\/p><\/article>\n      <\/div>\n      <div class=\"nit-callout nit-callout--success\"><p class=\"nit-callout__title\">Database thinking<\/p><p><strong>Identify the things \u2192 identify their properties \u2192 identify how they relate.<\/strong><\/p><\/div>\n    <\/section>\n\n    <section class=\"nit-section-panel\" id=\"inside-dbms\">\n      <h2>What happens inside a DBMS after a query arrives?<\/h2>\n      <p>\u201cThe database searches the table\u201d is useful for a first explanation, but a real database management system does more. PostgreSQL, for example, creates an execution plan that can use different scan and join strategies depending on the query and available structures. <sup><a href=\"#ref-4\">[4]<\/a><\/sup><\/p>\n\n      <ol class=\"nit-checklist\">\n        <li><strong>Receive:<\/strong> the DBMS receives a query or data operation.<\/li>\n        <li><strong>Understand:<\/strong> it identifies the referenced tables, columns, conditions and operation.<\/li>\n        <li><strong>Plan:<\/strong> the query planner chooses how to access and combine the required information.<\/li>\n        <li><strong>Locate:<\/strong> the system reads the relevant data, potentially using an index where appropriate.<\/li>\n        <li><strong>Check rules:<\/strong> constraints, data types, permissions and transaction rules still apply.<\/li>\n        <li><strong>Read or change:<\/strong> the required operation is performed.<\/li>\n        <li><strong>Return:<\/strong> the result or operation status goes back to the application.<\/li>\n      <\/ol>\n\n      <h3>What is an index?<\/h3>\n      <p>An index is an additional data structure that can help a database find suitable rows faster. PostgreSQL&#8217;s documentation notes that indexes can substantially improve retrieval speed for suitable queries, but they also add overhead and must be used sensibly. <sup><a href=\"#ref-5\">[5]<\/a><\/sup><\/p>\n      <div class=\"nit-callout nit-callout--warning\"><p class=\"nit-callout__title\">More indexes are not automatically better<\/p><p>Indexes consume storage and must be maintained when data changes. Good indexing starts with the queries and workloads the application actually needs.<\/p><\/div>\n    <\/section>\n\n    <section class=\"nit-section-panel\" id=\"data-rules\">\n      <h2>How does a database stop bad data?<\/h2>\n      <p>A serious application should not accept every possible value blindly. Relational database constraints can protect important rules at the data layer. PostgreSQL documents <code>CHECK<\/code>, <code>NOT NULL<\/code>, <code>UNIQUE<\/code>, primary-key and foreign-key constraints. <sup><a href=\"#ref-3\">[3]<\/a><\/sup><\/p>\n\n      <div class=\"nit-concept-grid\">\n        <article class=\"nit-concept-card\"><h3>Required value<\/h3><p>A student ID can be required instead of allowing it to be empty.<\/p><\/article>\n        <article class=\"nit-concept-card\"><h3>Unique value<\/h3><p>An official student number can be prevented from appearing twice when uniqueness is required.<\/p><\/article>\n        <article class=\"nit-concept-card\"><h3>Valid relationship<\/h3><p>A payment can be prevented from pointing to a student record that does not exist.<\/p><\/article>\n        <article class=\"nit-concept-card\"><h3>Valid range<\/h3><p>A <code>CHECK<\/code> constraint can enforce a rule such as <code>price &gt; 0<\/code>. <sup><a href=\"#ref-3\">[3]<\/a><\/sup><\/p><\/article>\n      <\/div>\n      <p>This is part of <strong>data integrity<\/strong>: keeping stored information consistent with the rules of the system.<\/p>\n    <\/section>\n\n    <section class=\"nit-section-panel\" id=\"transactions\">\n      <h2>CRUD and transactions: how applications change data safely<\/h2>\n      <p>Most database-driven applications repeatedly perform four basic categories of operation, often summarised as <strong>CRUD<\/strong>.<\/p>\n\n      <div class=\"nit-tech-board\">\n        <article class=\"nit-tech-card\"><h3>Create<\/h3><p>Add information\u2014for example, register a new student or create a new order.<\/p><\/article>\n        <article class=\"nit-tech-card\"><h3>Read<\/h3><p>Retrieve information\u2014for example, display a student profile or check stock.<\/p><\/article>\n        <article class=\"nit-tech-card\"><h3>Update<\/h3><p>Change existing information\u2014for example, update a phone number or reduce stock.<\/p><\/article>\n        <article class=\"nit-tech-card\"><h3>Delete<\/h3><p>Remove information when deletion is permitted by the application&#8217;s rules.<\/p><\/article>\n      <\/div>\n\n      <h3>Practical example: an online shop<\/h3>\n      <p>A product starts with <strong>24 school bags<\/strong>. A customer orders two. The application may need to check stock, create the order and reduce stock to 22.<\/p>\n      <div class=\"nit-project-grid\">\n        <article class=\"nit-project-card\" data-project=\"01\"><h3>Read product<\/h3><p>Confirm product <code>301<\/code> exists.<\/p><\/article>\n        <article class=\"nit-project-card\" data-project=\"02\"><h3>Read stock<\/h3><p>Current stock is 24; requested quantity is 2.<\/p><\/article>\n        <article class=\"nit-project-card\" data-project=\"03\"><h3>Create order<\/h3><p>Record the accepted order and its items.<\/p><\/article>\n        <article class=\"nit-project-card\" data-project=\"04\"><h3>Update stock<\/h3><p><strong>24 \u2212 2 = 22.<\/strong> Save the new stock level and return confirmation.<\/p><\/article>\n      <\/div>\n\n      <h3>What if the application fails halfway?<\/h3>\n      <p>A transaction groups related operations into one logical unit. The essential idea is <strong>all or nothing<\/strong>: if a failure prevents the transaction from completing, its partial changes do not have to remain applied. <sup><a href=\"#ref-6\">[6]<\/a><\/sup><\/p>\n      <div class=\"nit-callout nit-callout--success\"><p class=\"nit-callout__title\">Transaction mental model<\/p><p><strong>Everything succeeds \u2192 COMMIT.<\/strong> <strong>Something fails \u2192 ROLLBACK.<\/strong> Transactions are especially important for payments, stock, bookings and other multi-step changes.<\/p><\/div>\n    <\/section>\n\n    <section class=\"nit-section-panel\" id=\"concurrency\">\n      <h2>What happens when two users act at the same time?<\/h2>\n      <p>Imagine one appointment slot: <strong>Tuesday at 10:30 a.m.<\/strong> Amina and Brian both open the booking page. Both initially see it as available, then both press <strong>Book<\/strong> almost together.<\/p>\n      <ol class=\"nit-checklist\">\n        <li><strong>Amina checks:<\/strong> the slot appears free.<\/li>\n        <li><strong>Brian checks:<\/strong> the slot also appears free to him.<\/li>\n        <li><strong>Amina submits:<\/strong> her booking reaches the server.<\/li>\n        <li><strong>Brian submits:<\/strong> his request arrives close behind.<\/li>\n        <li><strong>The database must preserve the rule:<\/strong> one slot cannot end up with two accepted bookings.<\/li>\n      <\/ol>\n      <p>This is a <strong>concurrency problem<\/strong>. Transactions are designed so incomplete changes are not exposed as if they were final, and database designs can combine transactions, constraints and appropriate concurrency controls to preserve important rules. <sup><a href=\"#ref-6\">[6]<\/a><\/sup><\/p>\n      <div class=\"nit-callout nit-callout--warning\"><p class=\"nit-callout__title\">The screen can be stale<\/p><p><strong>\u201cIt looked available on my screen\u201d does not guarantee that it is still available when the database receives the request.<\/strong> Real applications must handle that possibility.<\/p><\/div>\n    <\/section>\n\n    <section class=\"nit-section-panel\" id=\"comparisons\">\n      <h2>Database vs DBMS vs SQL vs backend vs API<\/h2>\n      <div class=\"nit-pg-table-wrap\">\n        <table class=\"nit-pg-table\">\n          <thead><tr><th scope=\"col\">Term<\/th><th scope=\"col\">Main role<\/th><th scope=\"col\">Beginner example<\/th><\/tr><\/thead>\n          <tbody>\n            <tr><th scope=\"row\">Database<\/th><td>Organised persistent data<\/td><td>Students, payments and results<\/td><\/tr>\n            <tr><th scope=\"row\">DBMS<\/th><td>Software that manages databases<\/td><td>Executes queries, constraints and transactions<\/td><\/tr>\n            <tr><th scope=\"row\">SQL<\/th><td>Language commonly used with relational databases<\/td><td><code>SELECT<\/code> matching results<\/td><\/tr>\n            <tr><th scope=\"row\">Backend<\/th><td>Application logic<\/td><td>Checks identity, permission and business rules<\/td><\/tr>\n            <tr><th scope=\"row\">API<\/th><td>Software communication interface<\/td><td>Defines how a frontend requests results<\/td><\/tr>\n            <tr><th scope=\"row\">Frontend<\/th><td>User interface<\/td><td>Displays the final results table<\/td><\/tr>\n          <\/tbody>\n        <\/table>\n      <\/div>\n      <p class=\"nit-pg-table-note\">On a phone, swipe the table sideways to view every column.<\/p>\n\n      <div class=\"nit-callout nit-callout--info\"><p class=\"nit-callout__title\">Keep the layers separate<\/p><p><strong>Backend \u2260 database.<\/strong> <strong>API \u2260 database.<\/strong> <strong>SQL \u2260 database.<\/strong> These parts cooperate, but each has a different responsibility.<\/p><\/div>\n\n      <h3>Database vs spreadsheet<\/h3>\n      <div class=\"nit-pg-table-wrap\">\n        <table class=\"nit-pg-table\"><thead><tr><th scope=\"col\">Need<\/th><th scope=\"col\">Spreadsheet<\/th><th scope=\"col\">Database<\/th><\/tr><\/thead><tbody>\n          <tr><td>Calculations and charts<\/td><td>Excellent<\/td><td>Usually handled by another layer<\/td><\/tr>\n          <tr><td>Small personal list<\/td><td>Often ideal<\/td><td>May be unnecessary<\/td><\/tr>\n          <tr><td>Connected operational data<\/td><td>Can become awkward<\/td><td>Strong fit<\/td><\/tr>\n          <tr><td>Relationships and constraints<\/td><td>Limited<\/td><td>Core capability<\/td><\/tr>\n          <tr><td>Application-driven transactions<\/td><td>Not its primary purpose<\/td><td>Core capability<\/td><\/tr>\n        <\/tbody><\/table>\n      <\/div>\n      <p>Microsoft&#8217;s guidance similarly distinguishes spreadsheets as especially useful for numerical analysis, while database software is better suited to organising, searching and managing relational data for multi-user scenarios. <sup><a href=\"#ref-7\">[7]<\/a><\/sup><\/p>\n\n      <h3>Does every website need a database?<\/h3>\n      <p>No. A static website can simply serve files. A database becomes useful when a site or application must persist and manage changing information such as accounts, orders, messages, bookings or enrolments. <sup><a href=\"#ref-13\">[13]<\/a><\/sup><\/p>\n\n      <h3>Where is a database stored?<\/h3>\n      <p>A database can run on a user&#8217;s device, a local computer, an organisation&#8217;s own server, a private network or cloud infrastructure. Browsers also provide local database technology such as IndexedDB. <sup><a href=\"#ref-8\">[8]<\/a><\/sup><\/p>\n    <\/section>\n\n    <section class=\"nit-section-panel\" id=\"database-types\">\n      <h2>Are all databases made of tables?<\/h2>\n      <p>No. Tables are central to relational databases, but modern applications use several database models. Current database guidance distinguishes relational systems from document, key-value, graph, vector and time-series approaches. <sup><a href=\"#ref-1\">[1]<\/a><\/sup><\/p>\n      <div class=\"nit-pg-table-wrap\">\n        <table class=\"nit-pg-table\"><thead><tr><th scope=\"col\">Database model<\/th><th scope=\"col\">Basic idea<\/th><th scope=\"col\">Example use<\/th><\/tr><\/thead><tbody>\n          <tr><th scope=\"row\">Relational<\/th><td>Tables, rows, columns and relationships<\/td><td>Orders, enrolments, finance<\/td><\/tr>\n          <tr><th scope=\"row\">Document<\/th><td>Document-like records<\/td><td>Flexible content and catalogues<\/td><\/tr>\n          <tr><th scope=\"row\">Key-value<\/th><td>Values retrieved through keys<\/td><td>Sessions and fast lookups<\/td><\/tr>\n          <tr><th scope=\"row\">Graph<\/th><td>Nodes and relationships<\/td><td>Highly connected networks<\/td><\/tr>\n          <tr><th scope=\"row\">Vector<\/th><td>Numerical representations used for similarity search<\/td><td>Semantic search and recommendations<\/td><\/tr>\n          <tr><th scope=\"row\">Time-series<\/th><td>Values organised around time<\/td><td>Sensors and monitoring<\/td><\/tr>\n        <\/tbody><\/table>\n      <\/div>\n      <p class=\"nit-pg-table-note\">On a phone, swipe the table sideways to view every column.<\/p>\n      <div class=\"nit-callout nit-callout--success\"><p class=\"nit-callout__title\">What should a beginner learn first?<\/p><p>Start with <strong>tables \u2192 rows \u2192 columns \u2192 keys \u2192 relationships \u2192 queries<\/strong>. Those relational ideas make the foundations visible before you move into specialised database models.<\/p><\/div>\n    <\/section>\n\n    <section class=\"nit-section-panel\" id=\"security\">\n      <h2>Does using a database automatically make an application secure?<\/h2>\n      <p>No. A database is only one part of application security. Developers still have to design authentication, authorisation, safe queries, permissions, password protection, backups and recovery deliberately.<\/p>\n\n      <div class=\"nit-tech-board\">\n        <article class=\"nit-tech-card\"><h3>Authentication<\/h3><p><strong>Who are you?<\/strong> The application establishes the identity associated with a request.<\/p><\/article>\n        <article class=\"nit-tech-card\"><h3>Authorisation<\/h3><p><strong>What may you access?<\/strong> Knowing a record ID does not mean a user should be allowed to read it.<\/p><\/article>\n        <article class=\"nit-tech-card\"><h3>Safe queries<\/h3><p>OWASP recommends parameterised queries so untrusted values remain data rather than becoming SQL syntax. <sup><a href=\"#ref-9\">[9]<\/a><\/sup><\/p><\/article>\n        <article class=\"nit-tech-card\"><h3>Least privilege<\/h3><p>Application database accounts should receive only the access they genuinely need. <sup><a href=\"#ref-9\">[9]<\/a><\/sup><\/p><\/article>\n        <article class=\"nit-tech-card\"><h3>Password storage<\/h3><p>Passwords should not be stored as readable plaintext; modern guidance recommends dedicated password-hashing methods. <sup><a href=\"#ref-10\">[10]<\/a><\/sup><\/p><\/article>\n        <article class=\"nit-tech-card\"><h3>Recovery<\/h3><p>Important systems also need appropriate backups and a tested way to recover after failures.<\/p><\/article>\n      <\/div>\n      <div class=\"nit-callout nit-callout--warning\"><p class=\"nit-callout__title\">A database is not a security guarantee<\/p><p>Security comes from the whole system: the application, database permissions, queries, authentication, infrastructure and operational practices must work together.<\/p><\/div>\n    <\/section>\n\n    <section class=\"nit-section-panel\" id=\"design-exercise\">\n      <h2>Try it yourself: design a small school database<\/h2>\n      <p>Do not start with code. Start with the real-world things you need to represent.<\/p>\n\n      <div class=\"nit-tech-board\">\n        <article class=\"nit-tech-card\"><h3>students<\/h3><p><code>student_id<\/code><br><code>student_name<\/code><br><code>phone<\/code><\/p><\/article>\n        <article class=\"nit-tech-card\"><h3>courses<\/h3><p><code>course_id<\/code><br><code>course_name<\/code><\/p><\/article>\n        <article class=\"nit-tech-card\"><h3>enrolments<\/h3><p><code>enrolment_id<\/code><br><code>student_id<\/code><br><code>course_id<\/code><\/p><\/article>\n        <article class=\"nit-tech-card\"><h3>payments<\/h3><p><code>payment_id<\/code><br><code>student_id<\/code><br><code>amount<\/code><br><code>payment_date<\/code><\/p><\/article>\n      <\/div>\n\n      <div class=\"nit-code-window\" aria-label=\"Simple school database relationship diagram\">\n        <div class=\"nit-code-window__bar\"><span class=\"nit-code-window__dot\"><\/span><span class=\"nit-code-window__dot\"><\/span><span class=\"nit-code-window__dot\"><\/span><span class=\"nit-code-window__file\">school-data-model.txt<\/span><\/div>\n        <div class=\"nit-code-window__body\">\n          <span class=\"nit-code-line\">students  1 \u2500\u2500\u2500\u2500\u2500&lt; enrolments &gt;\u2500\u2500\u2500\u2500\u2500 1  courses<\/span>\n          <span class=\"nit-code-line\">    \u2502<\/span>\n          <span class=\"nit-code-line\">    \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500&lt; payments<\/span>\n        <\/div>\n      <\/div>\n\n      <h3>Test the design with questions<\/h3>\n      <ol class=\"nit-checklist\">\n        <li><strong>Which course is Amina taking?<\/strong> Follow students \u2192 enrolments \u2192 courses.<\/li>\n        <li><strong>How much has Amina paid?<\/strong> Follow students \u2192 payments and total the matching rows.<\/li>\n        <li><strong>Can two students have the same name?<\/strong> Yes. Their unique IDs still distinguish them.<\/li>\n        <li><strong>Can a payment point to a student who does not exist?<\/strong> A foreign-key rule can prevent that relationship. <sup><a href=\"#ref-3\">[3]<\/a><\/sup><\/li>\n        <li><strong>What if one student takes two courses?<\/strong> Create two enrolment records rather than copying the whole student record.<\/li>\n      <\/ol>\n\n      <h3>A practical learning path<\/h3>\n      <div class=\"nit-project-grid\">\n        <article class=\"nit-project-card\" data-project=\"01\"><h3>Data foundations<\/h3><p>Tables, rows, columns, data types and records.<\/p><\/article>\n        <article class=\"nit-project-card\" data-project=\"02\"><h3>Identity + relationships<\/h3><p>Primary keys, foreign keys and one-to-many or many-to-many relationships.<\/p><\/article>\n        <article class=\"nit-project-card\" data-project=\"03\"><h3>SQL + integrity<\/h3><p>SELECT, INSERT, UPDATE, DELETE, filtering, joins, constraints and transactions.<\/p><\/article>\n        <article class=\"nit-project-card\" data-project=\"04\"><h3>Complete application<\/h3><p>Connect frontend \u2192 backend\/API \u2192 database \u2192 response, then add testing, security and performance work.<\/p><\/article>\n      <\/div>\n      <p>NIT&#8217;s SQL for Data Analysis guide is the natural next step for deeper relational querying. <sup><a href=\"#ref-11\">[11]<\/a><\/sup><\/p>\n    <\/section>\n\n    <section class=\"nit-section-panel\" id=\"three-models\">\n      <h2>The three database models to remember<\/h2>\n      <div class=\"nit-concept-grid\">\n        <article class=\"nit-concept-card\"><h3>Application flow<\/h3><p><strong>User \u2192 Frontend \u2192 Backend\/API \u2192 Database system \u2192 Backend \u2192 Frontend \u2192 User<\/strong><\/p><\/article>\n        <article class=\"nit-concept-card\"><h3>Relational structure<\/h3><p><strong>Tables \u2192 Rows \u2192 Columns \u2192 Keys \u2192 Relationships \u2192 Queries<\/strong><\/p><\/article>\n        <article class=\"nit-concept-card\"><h3>DBMS work<\/h3><p><strong>Receive \u2192 Understand \u2192 Plan \u2192 Locate \u2192 Check rules \u2192 Read\/change \u2192 Return<\/strong><\/p><\/article>\n      <\/div>\n      <p>If you understand those three flows, you already understand much of the foundation needed to begin working with databases in real applications.<\/p>\n    <\/section>\n\n    <section class=\"nit-section-panel\" id=\"related-guides\">\n      <h2>Continue the application-development sequence<\/h2>\n      <p>This article owns the <strong>data layer<\/strong>. Use the related guides when you are ready to go deeper into the surrounding layers instead of repeating those subjects here.<\/p>\n      <div class=\"nit-action-strip\">\n        <p>Choose the next concept you want to strengthen.<\/p>\n        <div class=\"nit-action-strip__buttons\">\n          <a class=\"nit-button nit-button--secondary\" href=\"https:\/\/niteducation.com\/resources\/what-is-an-api-web-development\/\">What Is an API?<\/a>\n          <a class=\"nit-button nit-button--secondary\" href=\"https:\/\/niteducation.com\/resources\/what-is-sql-for-data-analysis\/\">SQL for Data Analysis<\/a>\n          <a class=\"nit-button nit-button--secondary\" href=\"https:\/\/niteducation.com\/resources\/what-is-full-stack-software-development\/\">What Is Full-Stack Development?<\/a>\n        <\/div>\n      <\/div>\n    <\/section>\n\n    <section id=\"faq\" aria-labelledby=\"faq-title\">\n      <h2 id=\"faq-title\">Database FAQs for beginners<\/h2>\n      <div class=\"nit-faq\">\n        <details class=\"nit-faq__item\"><summary>What is a database in simple terms?<\/summary><div class=\"nit-faq__answer\"><p>A database is an organised collection of related data that can be stored, retrieved and managed. A DBMS is the software that manages that data.<\/p><\/div><\/details>\n        <details class=\"nit-faq__item\"><summary>What is an example of a database?<\/summary><div class=\"nit-faq__answer\"><p>A school database could contain students, courses, enrolments, results, attendance and payments. An online shop database might contain customers, products, orders and stock.<\/p><\/div><\/details>\n        <details class=\"nit-faq__item\"><summary>Is SQL a database?<\/summary><div class=\"nit-faq__answer\"><p>No. SQL is a language commonly used to perform operations on relational database systems.<\/p><\/div><\/details>\n        <details class=\"nit-faq__item\"><summary>What is a DBMS?<\/summary><div class=\"nit-faq__answer\"><p>A database management system is software that creates, stores, retrieves, updates and controls database data and operations.<\/p><\/div><\/details>\n        <details class=\"nit-faq__item\"><summary>What is the difference between a database and a table?<\/summary><div class=\"nit-faq__answer\"><p>A database can contain several tables. A table contains one structured category of related records.<\/p><\/div><\/details>\n        <details class=\"nit-faq__item\"><summary>What is a primary key?<\/summary><div class=\"nit-faq__answer\"><p>A primary key identifies each row uniquely and uses unique, non-null values. <sup><a href=\"#ref-3\">[3]<\/a><\/sup><\/p><\/div><\/details>\n        <details class=\"nit-faq__item\"><summary>What is a foreign key?<\/summary><div class=\"nit-faq__answer\"><p>A foreign key references a key in another table and helps preserve valid relationships between records. <sup><a href=\"#ref-3\">[3]<\/a><\/sup><\/p><\/div><\/details>\n        <details class=\"nit-faq__item\"><summary>Is Excel a database?<\/summary><div class=\"nit-faq__answer\"><p>Excel is spreadsheet software. Spreadsheets can store tabular data, but database systems are specialised for structured data management, relationships, constraints, queries and transactions. <sup><a href=\"#ref-7\">[7]<\/a><\/sup><\/p><\/div><\/details>\n        <details class=\"nit-faq__item\"><summary>Does every website need a database?<\/summary><div class=\"nit-faq__answer\"><p>No. A static website may work entirely from files. A database becomes useful when the application must persist and manage changing information such as accounts, orders, messages or bookings.<\/p><\/div><\/details>\n        <details class=\"nit-faq__item\"><summary>Where is a database stored?<\/summary><div class=\"nit-faq__answer\"><p>A database can run locally, on an organisation&#8217;s server, inside a private network, on a user&#8217;s device or on cloud infrastructure. The hosting arrangement is separate from the database model.<\/p><\/div><\/details>\n        <details class=\"nit-faq__item\"><summary>What database should a beginner learn first?<\/summary><div class=\"nit-faq__answer\"><p>A relational database is a strong starting point because it exposes tables, data types, keys, relationships, SQL, constraints, indexes and transactions clearly.<\/p><\/div><\/details>\n      <\/div>\n    <\/section>\n\n    <section class=\"nit-pg-enrol\" id=\"register\" aria-labelledby=\"enrol-title\">\n      <div class=\"nit-pg-enrol__copy\">\n        <p class=\"nit-pg-eyebrow\">Build with real data<\/p>\n        <h2 id=\"enrol-title\">Register for Full-Stack Software Development at NIT<\/h2>\n        <p>Learn how front-end interfaces, backend logic, APIs and databases work together in complete applications. NIT&#8217;s current programme includes SQL and NoSQL databases, data modelling, application integration, testing and full-stack project development. <sup><a href=\"#ref-12\">[12]<\/a><\/sup><\/p>\n      <\/div>\n      <div class=\"nit-pg-enrol__details\">\n        <p><span>Institutional training<\/span><strong>8 months<\/strong><\/p>\n        <p><span>Industrial attachment<\/span><strong>At least 3 months<\/strong><\/p>\n        <p><span>Current published tuition<\/span><strong>KSh 90,000<\/strong><\/p>\n      <\/div>\n      <div class=\"nit-pg-enrol__actions\">\n        <a class=\"nit-pg-button nit-pg-button--gold\" href=\"https:\/\/niteducation.com\/admissions\/\">Register \/ Apply<\/a>\n        <a class=\"nit-pg-button nit-pg-button--outline\" href=\"https:\/\/wa.me\/254713584858?text=Hello%20Newton%20Institute%20of%20Technology.%20I%20would%20like%20information%20about%20the%20Full-Stack%20Software%20Development%20Course.\" target=\"_blank\" rel=\"noopener\">Ask on WhatsApp<\/a>\n        <a class=\"nit-pg-button nit-pg-button--outline\" href=\"mailto:info@niteducation.com?subject=Full-Stack%20Software%20Development%20Enquiry\">Email Admissions<\/a>\n      <\/div>\n    <\/section>\n\n    <section class=\"nit-sources\" aria-labelledby=\"references-title\">\n      <h2 id=\"references-title\">References and further reading<\/h2>\n      <ul>\n        <li id=\"ref-1\"><a href=\"https:\/\/cloud.google.com\/discover\/databases\" rel=\"noopener\" target=\"_blank\">[1] Google Cloud \u2014 What is a database?<\/a>. Database definition, application use and current database-model overview.<\/li>\n        <li id=\"ref-2\"><a href=\"https:\/\/www.postgresql.org\/docs\/current\/ddl-basics.html\" rel=\"noopener\" target=\"_blank\">[2] PostgreSQL 18 Documentation \u2014 Table Basics<\/a>. Primary technical reference for relational tables, rows, columns and data types.<\/li>\n        <li id=\"ref-3\"><a href=\"https:\/\/www.postgresql.org\/docs\/current\/ddl-constraints.html\" rel=\"noopener\" target=\"_blank\">[3] PostgreSQL 18 Documentation \u2014 Constraints<\/a>. Primary keys, foreign keys, uniqueness, not-null rules, check constraints and referential integrity.<\/li>\n        <li id=\"ref-4\"><a href=\"https:\/\/www.postgresql.org\/docs\/18\/sql-explain.html\" rel=\"noopener\" target=\"_blank\">[4] PostgreSQL 18 Documentation \u2014 EXPLAIN<\/a>. Execution plans, sequential scans, index scans and join strategies.<\/li>\n        <li id=\"ref-5\"><a href=\"https:\/\/www.postgresql.org\/docs\/18\/indexes.html\" rel=\"noopener\" target=\"_blank\">[5] PostgreSQL 18 Documentation \u2014 Indexes<\/a>. Index performance benefits and maintenance overhead.<\/li>\n        <li id=\"ref-6\"><a href=\"https:\/\/www.postgresql.org\/docs\/current\/tutorial-transactions.html\" rel=\"noopener\" target=\"_blank\">[6] PostgreSQL 18 Tutorial \u2014 Transactions<\/a>. Atomic operations, commits, rollbacks and concurrent visibility.<\/li>\n        <li id=\"ref-7\"><a href=\"https:\/\/support.microsoft.com\/en-us\/excel\/using-access-or-excel-to-manage-your-data\" rel=\"noopener\" target=\"_blank\">[7] Microsoft Support \u2014 Using Access or Excel to manage your data<\/a>. Spreadsheet analysis versus relational data-management use cases.<\/li>\n        <li id=\"ref-8\"><a href=\"https:\/\/developer.mozilla.org\/en-US\/docs\/Glossary\/Database\" rel=\"noopener\" target=\"_blank\">[8] MDN Web Docs \u2014 Database glossary<\/a>. Web-development database overview and browser-side IndexedDB.<\/li>\n        <li id=\"ref-9\"><a href=\"https:\/\/cheatsheetseries.owasp.org\/cheatsheets\/SQL_Injection_Prevention_Cheat_Sheet\" rel=\"noopener\" target=\"_blank\">[9] OWASP Cheat Sheet Series \u2014 SQL Injection Prevention<\/a>. Parameterised queries and least-privilege database access.<\/li>\n        <li id=\"ref-10\"><a href=\"https:\/\/cheatsheetseries.owasp.org\/cheatsheets\/Password_Storage_Cheat_Sheet.html\" rel=\"noopener\" target=\"_blank\">[10] OWASP Cheat Sheet Series \u2014 Password Storage<\/a>. Password hashing and avoiding plaintext password storage.<\/li>\n        <li id=\"ref-11\"><a href=\"https:\/\/niteducation.com\/resources\/what-is-sql-for-data-analysis\/\">[11] Newton Institute of Technology \u2014 SQL for Data Analysis<\/a>. Internal next-step guide for relational querying, filtering, joins and analysis.<\/li>\n        <li id=\"ref-12\"><a href=\"https:\/\/niteducation.com\/resources\/full-stack-software-development-course\/\">[12] Newton Institute of Technology \u2014 Full-Stack Software Development Course<\/a>. Current programme duration, tuition and database\/application-development coverage.<\/li>\n        <li id=\"ref-13\"><a href=\"https:\/\/developer.mozilla.org\/en-US\/docs\/Learn_web_development\/Howto\/Web_mechanics\/What_is_a_web_server\" rel=\"noopener\" target=\"_blank\">[13] MDN Web Docs \u2014 What is a web server?<\/a>. Static and dynamic web-server concepts.<\/li>\n      <\/ul>\n      <p><strong>Information checked:<\/strong> 1 November 2026.<\/p>\n      <p><strong>Editorial responsibility:<\/strong> Newton Institute of Technology Editorial Team.<\/p>\n    <\/section>\n  <\/div>\n<\/article>\n","protected":false},"excerpt":{"rendered":"<p>Database Fundamentals Beginner Guide What Is a Database?How Databases Work in Real Applications Frontend \u00b7 Backend \u00b7 Database Follow data from a user&#8217;s screen into a database and back, then learn how tables, keys, queries, constraints, indexes and transactions make real applications work. Follow one real request Design a small database The data route Request [&hellip;]<\/p>\n","protected":false},"author":3,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"set","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"categories":[30],"tags":[774,773,772],"class_list":["post-3722","post","type-post","status-publish","format-standard","hentry","category-ict","tag-database-for-beginners","tag-how-databases-work","tag-what-is-a-database"],"_links":{"self":[{"href":"https:\/\/niteducation.com\/resources\/wp-json\/wp\/v2\/posts\/3722","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/niteducation.com\/resources\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/niteducation.com\/resources\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/niteducation.com\/resources\/wp-json\/wp\/v2\/users\/3"}],"replies":[{"embeddable":true,"href":"https:\/\/niteducation.com\/resources\/wp-json\/wp\/v2\/comments?post=3722"}],"version-history":[{"count":1,"href":"https:\/\/niteducation.com\/resources\/wp-json\/wp\/v2\/posts\/3722\/revisions"}],"predecessor-version":[{"id":3723,"href":"https:\/\/niteducation.com\/resources\/wp-json\/wp\/v2\/posts\/3722\/revisions\/3723"}],"wp:attachment":[{"href":"https:\/\/niteducation.com\/resources\/wp-json\/wp\/v2\/media?parent=3722"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/niteducation.com\/resources\/wp-json\/wp\/v2\/categories?post=3722"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/niteducation.com\/resources\/wp-json\/wp\/v2\/tags?post=3722"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}