Top 50 SQL Interview Questions for Data Analysts in 2025 (with Answers)
Landing a data analyst role in 2025 requires mastering SQL—the backbone of data manipulation and analysis. Whether you're preparing for interviews at tech giants or startups, this comprehensive guide covers the most frequently asked SQL questions, from fundamental concepts to advanced techniques.
Why SQL Remains Critical for Data Analysts in 2025
SQL continues to dominate the data landscape, with over 60% of data analyst job postings requiring SQL proficiency. As organizations generate exponential amounts of data, the ability to query, transform, and analyze information efficiently has never been more valuable.
Basic SQL Interview Questions (1-15)
1. What is SQL and why is it important for data analysts?
Answer: SQL (Structured Query Language) is a standardized programming language used to manage and manipulate relational databases. For data analysts, SQL is essential because it enables direct access to raw data, allows complex data transformations, and provides the foundation for data-driven insights. Unlike spreadsheet tools, SQL can handle millions of rows efficiently and integrates seamlessly with business intelligence platforms.
2. Explain the difference between WHERE and HAVING clauses.
Answer:
WHERE filters rows before grouping occurs and cannot be used with aggregate functions
HAVING filters groups after aggregation and works with aggregate functions like SUM, COUNT, AVG
-- WHERE example
SELECT * FROM sales WHERE amount > 1000;
-- HAVING example
SELECT region, SUM(amount)
FROM sales
GROUP BY region
HAVING SUM(amount) > 50000;
3. What are the different types of JOINs in SQL?
Answer:
INNER JOIN: Returns matching records from both tables
LEFT JOIN (LEFT OUTER JOIN): Returns all records from the left table and matched records from the right
RIGHT JOIN (RIGHT OUTER JOIN): Returns all records from the right table and matched records from the left
FULL OUTER JOIN: Returns all records when there's a match in either table
CROSS JOIN: Returns the Cartesian product of both tables
SELF JOIN: Joins a table to itself
4. Explain PRIMARY KEY and FOREIGN KEY.
Answer:
PRIMARY KEY: Uniquely identifies each record in a table. Cannot contain NULL values and must be unique
FOREIGN KEY: A field that links two tables together by referencing the PRIMARY KEY of another table, maintaining referential integrity
CREATE TABLE customers (
customer_id INT PRIMARY KEY,
customer_name VARCHAR(100)
);
CREATE TABLE orders (
order_id INT PRIMARY KEY,
customer_id INT,
FOREIGN KEY (customer_id) REFERENCES customers(customer_id)
);
5. What is the difference between DELETE, TRUNCATE, and DROP?
Answer:
DELETE: Removes specific rows, can use WHERE clause, can be rolled back, slower
TRUNCATE: Removes all rows, cannot use WHERE clause, faster than DELETE, can be rolled back in some databases
DROP: Removes the entire table structure and data, cannot be rolled back
6. Explain aggregate functions in SQL.
Answer: Aggregate functions perform calculations on multiple rows and return a single value:
COUNT(): Counts number of rows
SUM(): Calculates total sum
AVG(): Calculates average value
MIN(): Finds minimum value
MAX(): Finds maximum value
SELECT
COUNT(*) as total_orders,
SUM(amount) as total_revenue,
AVG(amount) as avg_order_value,
MIN(amount) as min_order,
MAX(amount) as max_order
FROM orders;
7. What is the difference between UNION and UNION ALL?
Answer:
UNION: Combines results from multiple SELECT statements, removes duplicates, slower
UNION ALL: Combines results and keeps all duplicates, faster
SELECT customer_id FROM customers_2024
UNION
SELECT customer_id FROM customers_2025;
8. Explain NULL values and how to handle them.
Answer: NULL represents missing or unknown data. Key points:
NULL is not equal to zero or empty string
Use IS NULL or IS NOT NULL (not = NULL)
Functions like COALESCE() and IFNULL() handle NULLs
SELECT
customer_name,
COALESCE(phone_number, 'Not Provided') as phone
FROM customers
WHERE email IS NOT NULL;
9. What is a subquery and what are its types?
Answer: A subquery is a query nested inside another query. Types include:
Scalar subquery: Returns single value
Row subquery: Returns single row
Table subquery: Returns multiple rows/columns
Correlated subquery: References outer query
SELECT employee_name, salary
FROM employees
WHERE salary > (SELECT AVG(salary) FROM employees);
10. Explain the ORDER BY clause.
Answer: ORDER BY sorts the result set in ascending (ASC) or descending (DESC) order.
SELECT product_name, price
FROM products
ORDER BY price DESC, product_name ASC;
11. What is GROUP BY and when do you use it?
Answer: GROUP BY groups rows with the same values into summary rows, typically used with aggregate functions to create reports.
SELECT
category,
COUNT(*) as product_count,
AVG(price) as avg_price
FROM products
GROUP BY category;
12. Explain the DISTINCT keyword.
Answer: DISTINCT removes duplicate values from the result set.
SELECT DISTINCT country FROM customers;
SELECT COUNT(DISTINCT customer_id) as unique_customers FROM orders;
13. What are SQL constraints?
Answer: Constraints enforce rules on data in tables:
NOT NULL: Column cannot have NULL values
UNIQUE: All values must be different
PRIMARY KEY: Combination of NOT NULL and UNIQUE
FOREIGN KEY: Links tables together
CHECK: Ensures values meet specific condition
DEFAULT: Sets default value if none provided
14. Explain the LIMIT clause (or TOP/ROWNUM).
Answer: LIMIT restricts the number of rows returned.
-- MySQL/PostgreSQL
SELECT * FROM customers ORDER BY signup_date DESC LIMIT 10;
-- SQL Server
SELECT TOP 10 * FROM customers ORDER BY signup_date DESC;
15. What is the difference between CHAR and VARCHAR?
Answer:
CHAR: Fixed-length string, pads with spaces, faster for fixed-size data
VARCHAR: Variable-length string, uses only needed space, more flexible
Intermediate SQL Interview Questions (16-35)
16. Write a query to find the second highest salary.
Answer:
-- Method 1: Using LIMIT with OFFSET
SELECT DISTINCT salary
FROM employees
ORDER BY salary DESC
LIMIT 1 OFFSET 1;
-- Method 2: Using subquery
SELECT MAX(salary)
FROM employees
WHERE salary < (SELECT MAX(salary) FROM employees);
17. Explain window functions with an example.
Answer: Window functions perform calculations across rows related to the current row without collapsing the result set.
SELECT
employee_name,
department,
salary,
AVG(salary) OVER (PARTITION BY department) as dept_avg_salary,
RANK() OVER (ORDER BY salary DESC) as salary_rank
FROM employees;
18. What is the difference between RANK(), DENSE_RANK(), and ROW_NUMBER()?
Answer:
ROW_NUMBER(): Assigns unique sequential integers (1,2,3,4...)
RANK(): Assigns rank with gaps after ties (1,2,2,4...)
DENSE_RANK(): Assigns rank without gaps (1,2,2,3...)
SELECT
student_name,
score,
ROW_NUMBER() OVER (ORDER BY score DESC) as row_num,
RANK() OVER (ORDER BY score DESC) as rank,
DENSE_RANK() OVER (ORDER BY score DESC) as dense_rank
FROM students;
19. Write a query to find duplicate records.
Answer:
SELECT
email,
COUNT(*) as duplicate_count
FROM users
GROUP BY email
HAVING COUNT(*) > 1;
20. Explain CASE statements with an example.
Answer: CASE provides conditional logic in SQL queries.
SELECT
product_name,
price,
CASE
WHEN price < 100 THEN 'Budget'
WHEN price BETWEEN 100 AND 500 THEN 'Mid-Range'
ELSE 'Premium'
END as price_category
FROM products;
21. How do you find the nth highest value?
Answer:
-- Using DENSE_RANK
WITH ranked_salaries AS (
SELECT
salary,
DENSE_RANK() OVER (ORDER BY salary DESC) as rank
FROM employees
)
SELECT DISTINCT salary
FROM ranked_salaries
WHERE rank = 5; -- 5th highest
22. Explain self-join with a practical example.
Answer: Self-join joins a table to itself, useful for hierarchical data.
-- Find employees and their managers
SELECT
e.employee_name as employee,
m.employee_name as manager
FROM employees e
LEFT JOIN employees m ON e.manager_id = m.employee_id;
23. Write a query to calculate running totals.
Answer:
SELECT
order_date,
daily_revenue,
SUM(daily_revenue) OVER (ORDER BY order_date) as running_total
FROM daily_sales
ORDER BY order_date;
24. What are indexes and why are they important?
Answer: Indexes are database objects that improve query performance by creating pointers to data. They speed up SELECT queries but can slow down INSERT, UPDATE, and DELETE operations. Types include:
Clustered index: Determines physical order of data
Non-clustered index: Separate structure pointing to data
Unique index: Ensures uniqueness
Composite index: Index on multiple columns
25. Explain the difference between correlated and non-correlated subqueries.
Answer:
Non-correlated: Executes once independently of outer query
Correlated: Executes for each row of outer query, references outer query columns
-- Correlated subquery
SELECT e1.employee_name, e1.salary
FROM employees e1
WHERE e1.salary > (
SELECT AVG(e2.salary)
FROM employees e2
WHERE e2.department = e1.department
);
26. How do you handle date and time in SQL?
Answer:
-- Extract date parts
SELECT
order_date,
YEAR(order_date) as year,
MONTH(order_date) as month,
DAY(order_date) as day,
DATEPART(quarter, order_date) as quarter
FROM orders;
-- Date calculations
SELECT
DATEDIFF(day, start_date, end_date) as days_difference,
DATEADD(month, 3, order_date) as three_months_later
FROM subscriptions;
27. Write a query to pivot data.
Answer:
-- Convert rows to columns
SELECT
product_id,
SUM(CASE WHEN month = 'Jan' THEN sales ELSE 0 END) as Jan_Sales,
SUM(CASE WHEN month = 'Feb' THEN sales ELSE 0 END) as Feb_Sales,
SUM(CASE WHEN month = 'Mar' THEN sales ELSE 0 END) as Mar_Sales
FROM monthly_sales
GROUP BY product_id;
28. Explain common table expressions (CTEs).
Answer: CTEs are temporary named result sets that exist within a single query, improving readability and enabling recursive queries.
WITH high_value_customers AS (
SELECT customer_id, SUM(amount) as total_spent
FROM orders
GROUP BY customer_id
HAVING SUM(amount) > 10000
)
SELECT
c.customer_name,
h.total_spent
FROM customers c
INNER JOIN high_value_customers h ON c.customer_id = h.customer_id;
29. How do you find records that exist in one table but not another?
Answer:
-- Method 1: LEFT JOIN with NULL check
SELECT c.*
FROM customers c
LEFT JOIN orders o ON c.customer_id = o.customer_id
WHERE o.customer_id IS NULL;
-- Method 2: NOT EXISTS
SELECT c.*
FROM customers c
WHERE NOT EXISTS (
SELECT 1 FROM orders o WHERE o.customer_id = c.customer_id
);
-- Method 3: NOT IN
SELECT * FROM customers
WHERE customer_id NOT IN (SELECT customer_id FROM orders);
30. Explain string functions in SQL.
Answer:
SELECT
CONCAT(first_name, ' ', last_name) as full_name,
UPPER(email) as email_upper,
LOWER(city) as city_lower,
LENGTH(description) as desc_length,
SUBSTRING(phone, 1, 3) as area_code,
TRIM(product_name) as trimmed_name,
REPLACE(address, 'Street', 'St') as short_address
FROM customers;
31. Write a query to calculate year-over-year growth.
Answer:
WITH yearly_sales AS (
SELECT
YEAR(order_date) as year,
SUM(amount) as total_sales
FROM orders
GROUP BY YEAR(order_date)
)
SELECT
current.year,
current.total_sales,
previous.total_sales as previous_year_sales,
ROUND(((current.total_sales - previous.total_sales) / previous.total_sales * 100), 2) as yoy_growth_pct
FROM yearly_sales current
LEFT JOIN yearly_sales previous ON current.year = previous.year + 1;
32. What is normalization and why is it important?
Answer: Normalization is the process of organizing data to reduce redundancy and improve data integrity. Normal forms include:
1NF: Atomic values, no repeating groups
2NF: 1NF + no partial dependencies
3NF: 2NF + no transitive dependencies
BCNF: Stricter version of 3NF
33. Explain ACID properties.
Answer: ACID ensures reliable database transactions:
Atomicity: Transaction completes fully or not at all
Consistency: Data remains valid before and after transaction
Isolation: Concurrent transactions don't interfere
Durability: Committed changes persist even after system failure
34. Write a query to find the most frequently occurring value.
Answer:
SELECT
product_id,
COUNT(*) as frequency
FROM orders
GROUP BY product_id
ORDER BY frequency DESC
LIMIT 1;
35. How do you handle performance optimization in SQL?
Answer: Key strategies:
Use appropriate indexes
Avoid SELECT *, specify needed columns
Use WHERE clauses to filter early
Minimize subqueries, prefer JOINs when possible
Use EXPLAIN/EXECUTION PLAN to analyze queries
Partition large tables
Update statistics regularly
Avoid functions in WHERE clauses on indexed columns
Advanced SQL Interview Questions (36-50)
36. Write a recursive CTE query.
Answer:
-- Find organizational hierarchy
WITH RECURSIVE employee_hierarchy AS (
-- Base case: top-level employees
SELECT employee_id, employee_name, manager_id, 1 as level
FROM employees
WHERE manager_id IS NULL
UNION ALL
-- Recursive case
SELECT e.employee_id, e.employee_name, e.manager_id, eh.level + 1
FROM employees e
INNER JOIN employee_hierarchy eh ON e.manager_id = eh.employee_id
)
SELECT * FROM employee_hierarchy ORDER BY level, employee_name;
37. Explain query execution order.
Answer: SQL query execution order:
FROM (including JOINs)
WHERE
GROUP BY
HAVING
SELECT
DISTINCT
ORDER BY
LIMIT/OFFSET
Note: This differs from the writing order.
38. Write a query to detect gaps in sequential data.
Answer:
-- Find missing invoice numbers
WITH invoice_sequence AS (
SELECT
invoice_number,
LEAD(invoice_number) OVER (ORDER BY invoice_number) as next_invoice
FROM invoices
)
SELECT
invoice_number as gap_starts_after,
next_invoice as gap_ends_before,
next_invoice - invoice_number - 1 as missing_count
FROM invoice_sequence
WHERE next_invoice - invoice_number > 1;
39. Explain transaction isolation levels.
Answer: Isolation levels control concurrent transaction behavior:
READ UNCOMMITTED: Lowest isolation, allows dirty reads
READ COMMITTED: Prevents dirty reads
REPEATABLE READ: Prevents dirty and non-repeatable reads
SERIALIZABLE: Highest isolation, prevents all anomalies
40. Write a query for cohort analysis.
Answer:
WITH first_purchase AS (
SELECT
customer_id,
DATE_TRUNC('month', MIN(order_date)) as cohort_month
FROM orders
GROUP BY customer_id
)
SELECT
fp.cohort_month,
DATE_TRUNC('month', o.order_date) as order_month,
COUNT(DISTINCT o.customer_id) as customers,
SUM(o.amount) as revenue
FROM orders o
INNER JOIN first_purchase fp ON o.customer_id = fp.customer_id
GROUP BY fp.cohort_month, DATE_TRUNC('month', o.order_date)
ORDER BY fp.cohort_month, order_month;
41. How do you handle slowly changing dimensions (SCD)?
Answer: SCD tracks historical changes in dimension tables:
Type 1: Overwrite old values (no history)
Type 2: Add new row with effective dates (full history)
Type 3: Add new columns for previous values (limited history)
-- SCD Type 2 example
CREATE TABLE customer_dimension (
customer_key INT PRIMARY KEY,
customer_id INT,
customer_name VARCHAR(100),
address VARCHAR(200),
effective_date DATE,
expiry_date DATE,
is_current BOOLEAN
);
42. Write a query for calculating percentiles.
Answer:
SELECT
product_category,
PERCENTILE_CONT(0.25) WITHIN GROUP (ORDER BY price) as percentile_25,
PERCENTILE_CONT(0.50) WITHIN GROUP (ORDER BY price) as median,
PERCENTILE_CONT(0.75) WITHIN GROUP (ORDER BY price) as percentile_75,
PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY price) as percentile_95
FROM products
GROUP BY product_category;
43. Explain materialized views vs regular views.
Answer:
Regular View: Virtual table, queries underlying tables each time
Materialized View: Physical copy of data, pre-computed results, needs refresh, faster queries
CREATE MATERIALIZED VIEW monthly_sales_summary AS
SELECT
DATE_TRUNC('month', order_date) as month,
category,
SUM(amount) as total_sales
FROM orders
GROUP BY DATE_TRUNC('month', order_date), category;
44. Write a query to calculate customer lifetime value.
Answer:
WITH customer_metrics AS (
SELECT
customer_id,
MIN(order_date) as first_order_date,
MAX(order_date) as last_order_date,
COUNT(DISTINCT order_id) as total_orders,
SUM(amount) as total_spent,
AVG(amount) as avg_order_value
FROM orders
GROUP BY customer_id
)
SELECT
customer_id,
total_spent as historical_ltv,
DATEDIFF(day, first_order_date, last_order_date) as customer_lifespan_days,
total_orders,
avg_order_value,
CASE
WHEN DATEDIFF(day, first_order_date, last_order_date) > 0
THEN total_spent / DATEDIFF(day, first_order_date, last_order_date) * 365
ELSE total_spent
END as annualized_ltv
FROM customer_metrics;
45. How do you optimize JOIN operations?
Answer: Optimization techniques:
Index join columns (especially foreign keys)
Join on indexed columns
Filter data before joining (push down predicates)
Use appropriate join type
Consider join order (smaller tables first)
Analyze execution plans
Use covering indexes when possible
46. Write a query to detect outliers using IQR method.
Answer:
WITH quartiles AS (
SELECT
PERCENTILE_CONT(0.25) WITHIN GROUP (ORDER BY price) as Q1,
PERCENTILE_CONT(0.75) WITHIN GROUP (ORDER BY price) as Q3
FROM products
),
outlier_bounds AS (
SELECT
Q1,
Q3,
Q3 - Q1 as IQR,
Q1 - 1.5 * (Q3 - Q1) as lower_bound,
Q3 + 1.5 * (Q3 - Q1) as upper_bound
FROM quartiles
)
SELECT
p.product_id,
p.product_name,
p.price,
CASE
WHEN p.price < o.lower_bound THEN 'Low Outlier'
WHEN p.price > o.upper_bound THEN 'High Outlier'
ELSE 'Normal'
END as outlier_status
FROM products p
CROSS JOIN outlier_bounds o
WHERE p.price < o.lower_bound OR p.price > o.upper_bound;
47. Explain partitioning and its benefits.
Answer: Partitioning divides large tables into smaller, manageable pieces:
Range partitioning: Based on value ranges (dates, IDs)
List partitioning: Based on discrete values
Hash partitioning: Based on hash function
Composite partitioning: Combination of methods
Benefits: Improved query performance, easier maintenance, better data management.
48. Write a query for funnel analysis.
Answer:
WITH funnel_steps AS (
SELECT
user_id,
MAX(CASE WHEN event_type = 'page_view' THEN 1 ELSE 0 END) as viewed,
MAX(CASE WHEN event_type = 'add_to_cart' THEN 1 ELSE 0 END) as added_cart,
MAX(CASE WHEN event_type = 'checkout' THEN 1 ELSE 0 END) as checked_out,
MAX(CASE WHEN event_type = 'purchase' THEN 1 ELSE 0 END) as purchased
FROM events
WHERE event_date >= '2025-01-01'
GROUP BY user_id
)
SELECT
SUM(viewed) as step1_views,
SUM(added_cart) as step2_cart,
SUM(checked_out) as step3_checkout,
SUM(purchased) as step4_purchase,
ROUND(SUM(added_cart)::DECIMAL / SUM(viewed) * 100, 2) as view_to_cart_pct,
ROUND(SUM(checked_out)::DECIMAL / SUM(added_cart) * 100, 2) as cart_to_checkout_pct,
ROUND(SUM(purchased)::DECIMAL / SUM(checked_out) * 100, 2) as checkout_to_purchase_pct
FROM funnel_steps;
49. What are window frame clauses and how do they work?
Answer: Window frame clauses define which rows to include in window function calculations:
SELECT
order_date,
daily_sales,
-- Moving average of last 7 days
AVG(daily_sales) OVER (
ORDER BY order_date
ROWS BETWEEN 6 PRECEDING AND CURRENT ROW
) as moving_avg_7day,
-- Cumulative sum
SUM(daily_sales) OVER (
ORDER BY order_date
ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
) as cumulative_sales,
-- Lead and lag with default values
LAG(daily_sales, 1, 0) OVER (ORDER BY order_date) as previous_day,
LEAD(daily_sales, 1, 0) OVER (ORDER BY order_date) as next_day
FROM daily_sales_table;
50. Write a query for RFM (Recency, Frequency, Monetary) analysis.
Answer:
WITH customer_rfm AS (
SELECT
customer_id,
DATEDIFF(day, MAX(order_date), CURRENT_DATE) as recency,
COUNT(DISTINCT order_id) as frequency,
SUM(amount) as monetary
FROM orders
GROUP BY customer_id
),
rfm_scores AS (
SELECT
customer_id,
recency,
frequency,
monetary,
NTILE(5) OVER (ORDER BY recency DESC) as R_score,
NTILE(5) OVER (ORDER BY frequency) as F_score,
NTILE(5) OVER (ORDER BY monetary) as M_score
FROM customer_rfm
)
SELECT
customer_id,
recency,
frequency,
monetary,
R_score,
F_score,
M_score,
CONCAT(R_score, F_score, M_score) as RFM_segment,
CASE
WHEN R_score >= 4 AND F_score >= 4 AND M_score >= 4 THEN 'Champions'
WHEN R_score >= 3 AND F_score >= 3 AND M_score >= 3 THEN 'Loyal Customers'
WHEN R_score >= 4 AND F_score <= 2 THEN 'New Customers'
WHEN R_score <= 2 AND F_score >= 3 THEN 'At Risk'
WHEN R_score <= 2 AND F_score <= 2 THEN 'Lost'
ELSE 'Other'
END as customer_category
FROM rfm_scores
ORDER BY R_score DESC, F_score DESC, M_score DESC;
Key Tips for SQL Interview Success
Before the Interview
Practice on real datasets - Use platforms like LeetCode, HackerRank, or Mode Analytics
Understand your database system - Know whether you're working with MySQL, PostgreSQL, SQL Server, etc.
Review the job description - Identify which SQL skills are most important for the role
Prepare to explain your thought process - Interviewers value problem-solving approach
During the Interview
Clarify requirements - Ask about table structures, data volumes, and expected output
Start with a simple solution - Optimize later if needed
Write readable code - Use proper formatting and meaningful aliases
Test your logic - Walk through sample data mentally
Discuss trade-offs - Mention performance considerations
Common Mistakes to Avoid
Forgetting to handle NULL values
Using SELECT * in production queries
Not considering query performance
Ignoring edge cases
Overcomplicating solutions
Essential SQL Resources for Continuous Learning
Practice Platforms: LeetCode SQL, HackerRank, StrataScratch, DataLemur
Documentation: Official database documentation (PostgreSQL, MySQL, SQL Server)
Online Courses: Mode Analytics SQL Tutorial, SQLBolt, Khan Academy
Books: "SQL Cookbook" by Anthony Molinaro, "SQL Performance Explained" by Markus Winand
Why Invest in Professional SQL Training?
While self-study is valuable, structured training programs offer:
✓ Hands-on projects with real-world datasets ✓ Expert guidance from industry professionals
✓ Interview preparation and mock sessions ✓ Career support and networking opportunities ✓ Certification that validates your skills
Our comprehensive Data Analytics program covers SQL from fundamentals to advanced optimization techniques, preparing you for roles at top companies. With live projects, personalized mentorship, and placement assistance, we've helped thousands of students transition into successful data analyst careers.
Conclusion
Mastering these 50 SQL interview questions will significantly boost your confidence and performance in data analyst interviews. Remember that SQL proficiency comes from consistent practice and real-world application. Focus on understanding concepts deeply rather than memorizing answers, and you'll be well-prepared to tackle any SQL challenge that comes your way.
Ready to accelerate your data analyst career? Our expert-led courses provide the structured learning, hands-on practice, and career support you need to land your dream role in 2025.
Start your journey today and join thousands of successful data analysts who transformed their careers with professional training!
Keywords: SQL interview questions, data analyst interview, SQL queries, database interview, SQL tutorial 2025, learn SQL, data analytics course, SQL certification, database queries, SQL practice questions
Related Blogs
Blogs
Latest Blog
Stay up-to-date with the latest technologies trends, IT market, job post & etc with our blogs
