diff --git a/docs/tech_docs/sql_notes.md b/docs/tech_docs/sql_notes.md
index 1e5f0ed..f1e71b0 100644
--- a/docs/tech_docs/sql_notes.md
+++ b/docs/tech_docs/sql_notes.md
@@ -1,3 +1,130 @@
+When facing complaints about a slow database, where the presumption is a database issue, it's crucial to approach troubleshooting systematically. Performance issues can stem from a myriad of factors, from query inefficiency, hardware limitations, to configuration missettings. This advanced technical guide aims to equip database administrators (DBAs) and developers with strategies to diagnose and resolve database performance bottlenecks.
+
+# Advanced Technical Guide: Troubleshooting a Slow Database
+
+## Step 1: Initial Assessment
+
+### 1.1 **Identify Symptoms**
+- Gather specific complaints: long-running queries, slow application performance, timeouts.
+- Determine if the issue is global (affecting all queries) or localized (specific queries or operations).
+
+### 1.2 **Monitor Database Performance Metrics**
+- Utilize built-in database monitoring tools to track CPU usage, memory utilization, I/O throughput, and other relevant metrics.
+- Identify abnormal patterns: spikes in CPU or I/O, memory pressure, etc.
+
+## Step 2: Narrow Down the Issue
+
+### 2.1 **Analyze Slow Queries**
+- Use query logs or performance schemas to identify slow-running queries.
+- Analyze execution plans for these queries to pinpoint inefficiencies (full table scans, missing indexes, etc.).
+
+### 2.2 **Check Database Configuration**
+- Review configuration settings that could impact performance: buffer pool size, max connections, query cache settings (if applicable).
+- Compare current configurations against recommended settings for your workload and DBMS.
+
+### 2.3 **Assess Hardware and Resource Utilization**
+- Determine if the hardware (CPU, RAM, storage) is adequate for your workload.
+- Check for I/O bottlenecks: slow disk access times, high I/O wait times.
+- Monitor network latency and bandwidth, especially in distributed database setups.
+
+## Step 3: Systematic Troubleshooting
+
+### 3.1 **Query Optimization**
+- Optimize slow-running queries: add missing indexes, rewrite inefficient queries, and consider query caching where applicable.
+- Evaluate the use of more efficient data types and schema designs to reduce data footprint and improve access times.
+
+### 3.2 **Database Maintenance**
+- Perform routine database maintenance: update statistics, rebuild indexes, and purge unnecessary data to keep the database lean and efficient.
+- Consider partitioning large tables to improve query performance and management.
+
+### 3.3 **Configuration Tuning**
+- Adjust database server configurations to better utilize available hardware resources. This might involve increasing buffer pool size, adjusting cache settings, or tuning connection pools.
+- Implement connection pooling and manage database connections efficiently to avoid overhead from frequent disconnections and reconnections.
+
+### 3.4 **Scale Resources**
+- If hardware resources are identified as a bottleneck, consider scaling up (more powerful hardware) or scaling out (adding more nodes, if supported).
+- Explore the use of faster storage solutions (e.g., SSDs over HDDs) for critical databases.
+
+### 3.5 **Application-Level Changes**
+- Review application logic for unnecessary database calls or operations that could be optimized.
+- Implement caching at the application level to reduce database load for frequently accessed data.
+
+## Step 4: Review and Continuous Monitoring
+
+### 4.1 **Implement Monitoring Solutions**
+- Set up comprehensive monitoring that covers database metrics, system performance, and application performance to quickly identify future issues.
+- Use alerting mechanisms for proactive issue detection based on thresholds.
+
+### 4.2 **Regular Reviews**
+- Conduct regular performance reviews to identify potential issues before they become critical.
+- Keep documentation of configurations, optimizations, and known issues for future reference.
+
+## Conclusion
+
+Troubleshooting a slow database requires a methodical approach to identify and rectify the root causes of performance issues. By systematically assessing and addressing each potential area of concern—from query performance and schema optimization to hardware resources and configuration settings—DBAs can significantly improve database performance. Continuous monitoring and regular maintenance are key to ensuring sustained database health and performance, allowing for proactive rather than reactive management of the database environment.
+
+---
+
+Crafting efficient SQL queries and troubleshooting slow queries are critical skills for optimizing database performance and ensuring the responsiveness of applications that rely on database operations. This advanced guide delves into strategies for writing high-performance SQL queries and methodologies for diagnosing and improving the performance of slow queries.
+
+# Advanced Guide to Crafting Efficient SQL Queries and Troubleshooting
+
+## Writing Efficient SQL Queries
+
+### 1. **Understand Your Data and Database Structure**
+- Familiarize yourself with the database schema, indexes, and the data distribution within tables (e.g., through histograms).
+
+### 2. **Make Use of Indexes**
+- Utilize indexes on columns that are frequently used in `WHERE`, `JOIN`, `ORDER BY`, and `GROUP BY` clauses. However, be mindful that excessive indexing can slow down write operations.
+
+### 3. **Optimize JOINs**
+- Use the appropriate type of JOIN for your query. Prefer `INNER JOIN` over `OUTER JOIN` when possible, as it is generally more efficient.
+- Ensure that the joined tables have indexes on the joined columns.
+
+### 4. **Limit the Data You Work With**
+- Be specific about the columns you select—avoid using `SELECT *`.
+- Use `WHERE` clauses to filter rows early and reduce the amount of data processed.
+
+### 5. **Use Subqueries and CTEs Wisely**
+- Common Table Expressions (CTEs) can improve readability, but they may not always be optimized by the query planner. Test performance with and without CTEs.
+- Materialized subqueries (in the `FROM` clause) can sometimes be optimized more efficiently than scalar or correlated subqueries.
+
+### 6. **Aggregate and Sort Efficiently**
+- When using `GROUP BY`, limit the number of grouping columns and consider indexing them.
+- Use `ORDER BY` judiciously, as sorting can be resource-intensive. Sort on indexed columns when possible.
+
+## Troubleshooting Slow Queries
+
+### 1. **Identify the Slow Query**
+- Use logging tools or query performance monitoring features provided by your RDBMS to identify slow-running queries.
+
+### 2. **Analyze the Execution Plan**
+- Most RDBMS offer query execution plans to understand how a query is executed. Look for full table scans, inefficient joins, and the use of indexes.
+
+### 3. **Optimize Data Access Patterns**
+- Rewrite queries to access only the necessary data. Consider changing `JOIN` conditions, using subqueries, or restructuring queries to make them more efficient.
+
+### 4. **Review and Optimize Indexes**
+- Ensure that your queries are using indexes efficiently. Adding, removing, or modifying indexes can significantly impact performance.
+- Consider index types (e.g., B-tree, hash, full-text) and their suitability for your queries.
+
+### 5. **Optimize Query Logic**
+- Simplify complex queries. Break down complex operations into simpler steps or multiple queries if it results in better performance.
+- Use set-based operations instead of looping constructs when dealing with large datasets.
+
+### 6. **Database Configuration and Server Resources**
+- Ensure that the database configuration is optimized for your workload. Parameters related to memory usage, file storage, and connection handling can impact performance.
+- Assess if server resource constraints (CPU, memory, I/O) are bottlenecks. Upgrading hardware or balancing the load may be necessary.
+
+### 7. **Regular Maintenance**
+- Perform regular maintenance tasks such as updating statistics, rebuilding indexes, and vacuuming (in PostgreSQL) to keep the database performing optimally.
+
+## Conclusion
+
+Efficient SQL query writing and effective troubleshooting of slow queries are fundamental to maintaining high database performance. By applying a thoughtful approach to query design, making judicious use of indexes, and systematically diagnosing performance issues through execution plans and database monitoring tools, developers and DBAs can ensure their databases support their application's needs with high efficiency. Regular review and optimization of queries and database settings are crucial as data volumes grow and application requirements evolve.
+
+---
+
 Creating an advanced guide on SQL data types involves delving into the nuances of choosing the most appropriate and performance-optimized types for various scenarios. Understanding and making informed decisions about data types is crucial for database efficiency, data integrity, and optimal storage. This guide targets intermediate to advanced SQL users, focusing on common relational database management systems (RDBMS) like PostgreSQL, MySQL, SQL Server, and Oracle.
 
 # Advanced Guide on SQL Data Types and Their Selection