5-Year Implementation Engineer Interviews: Basic Linux & SQL Questions Revealing Skill Gaps

Linux Fundamentals: The Foundation

The author interviews five candidates with ~5 years of implementation engineering experience. The Linux questions cover daily operational tasks.

1. Check CPU, Memory, Disk Usage and Find Largest Directories

Standard answer:

CPU: top
Memory: free -h
Disk: df -h
# -h shows human-readable units (KB/MB/GB) instead of raw bytes

To locate the largest directories when disk is full:

du -sh /*          # check first-level directories
du -sh * | sort -rh  # drill down recursively, sort by size descending

Three steps pinpoint the culprit.

2. View Running Java Process Startup Parameters and JVM Heap Settings

Two-step method:

# Step 1: find PID
ps aux | grep java
ps -ef | grep java  # also works
# Step 2: with PID, view full command line and JVM flags
ps -fp <PID>        # or cat /proc/<PID>/cmdline

3. Service Listens on Port but Local Access Fails — Troubleshooting Steps

Checklist (each step required): netstat -tulnp | grep <port> — confirm port is actually listening

Check firewall ( firewalld / iptables) for blocking rules

Test local connectivity with telnet or ss For cross-machine access, verify routing and cloud security groups

Ensure service binds to 0.0.0.0 or correct NIC IP, not just 127.0.0.1

Missing any step leaves the issue unresolved.

4. Find and Delete Log Files Older Than 30 Days in Current Directory

One-liner (use with caution in production):

find ./ -type f -mtime +30 -name "*.log" -exec rm -rf {} \;

Safer approach: replace -exec rm with -exec ls -l {} \; to verify file list first, or use -delete flag.

5. Shell Script to Scan Subnet for Online IPs

Core idea: iterate IP range (e.g., 192.168.1.1-255), ping each with ping -c 1 -W 1, output reachable IPs. The key is automation mindset — using for loop or seq to generate IP sequence — not the ping command itself.

SQL Proficiency: The Other Leg

Database operations are essential for implementation engineers. Questions reflect high-frequency daily scenarios.

1. Frequently Used Database Functions — Most Memorable One

Open-ended. Weak answers: only COUNT() / SUM(). Strong answers mention ROW_NUMBER() for pagination, DATE_FORMAT() for time handling, CONCAT() for string concatenation, REGEXP_REPLACE() for cleaning dirty data — indicating real battle scars.

2. INNER JOIN vs LEFT JOIN vs RIGHT JOIN

INNER JOIN : intersection — only rows matching both tables

LEFT JOIN : keep all left table rows; right side fills NULL where no match

RIGHT JOIN : mirror of LEFT JOIN

Confusion here leads to broken complex reports.

3. Delete Duplicate Rows in Log Table — Keep Smallest ID

Core logic: identify duplicates, delete extras.

DELETE FROM log_table
WHERE id NOT IN (
  SELECT MIN(id) FROM log_table GROUP BY duplicate_columns
);

Or use window function:

WITH cte AS (
  SELECT id, ROW_NUMBER() OVER (PARTITION BY duplicate_columns ORDER BY id) AS rn
  FROM log_table
)
DELETE FROM log_table WHERE id IN (SELECT id FROM cte WHERE rn > 1);

Manual deletion fails at scale.

4. Replace Chinese Enumeration Comma (、) with Regular Comma, Truncate to 5 Characters

Nested functions: SUBSTR(REPLACE(type_column, '、', ','), 1, 5) One step cleans dirty data; missing a step breaks imports.

5. Output Full Administrative Hierarchy (Province → City → District → Street/Town) as Tree

Tests hierarchical data handling. Answer depends on database version:

Modern (MySQL 8.0+) : WITH RECURSIVE CTE — clean, single query

Legacy (MySQL 5.x) : no CTE — must use stored procedures, application-layer recursion, or path column with LIKE pattern matching

Oracle : proprietary START WITH ... CONNECT BY PRIOR syntax

Knowing recursion is entry-level; instantly recognizing version/design constraints marks a production-hardened engineer.

Closing Thoughts

These questions are "free points" for engineers with real battle experience, but stump those with weak fundamentals. The goal isn't to trick — implementation engineering is about decomposing complex problems into basic operations. Shaky basics make every project a minefield.

Most disappointing interview response: "I'll just ask AI." Tools evolve and should be used, but the interview mirrors the workplace — core evaluation is your first reaction, decomposition logic, and communication. AI is an external brain; it cannot replace internalized reasoning. Showing how you think, even imperfectly, signals far more potential than "I'll use AI." Professional trust begins with demonstrated expertise and sincerity.