Introduction
Preparing for a Secure IT interview requires a good understanding of programming, problem-solving, databases, and practical application development. Based on the interview experience shared by Payilagam trainees, the first round includes a written test, a technical/programming interview, and a CRUD web application practical.
This article brings together the questions and practical task shared by the trainees to help candidates understand what they may need to prepare. The programming section covers problems related to arrays, strings, matrices, and other common coding concepts. Along with the questions, we will also look at the Java approach and code so that candidates can practise the problems before attending the interview.
The round also includes a practical task where candidates need to build a web application that can perform Create, Read, Update, and Delete (CRUD) operations. This tests how well a candidate can connect the frontend, backend, and database to build a working application.
The interview details and questions in this article are based on the experience shared by Payilagam trainees. They are intended to help candidates prepare better and understand the type of programming and practical tasks they may face.
Table of Contents:
The first round of the Secure IT interview is divided into different parts that test both technical knowledge and practical programming skills. According to the interview experience shared by Payilagam trainees, candidates need to complete the written test, technical and programming discussion, and a CRUD web application practical.
| Stage | Duration | Total |
|---|---|---|
| Written Test | Included in Round 1 | Part of 3-hour Round 1 |
| Technical / Programming Interview | 1 hour 30 minutes | 1:30 |
| CRUD Web Application Practical | 1 hour 30 minutes | 1:30 |
| Total Round 1 Duration | 3 hours |
The written test is included as part of the first round. After that, candidates move to the technical and programming interview, where their problem-solving and coding skills are tested. This portion takes 1 hour and 30 minutes.
The next 1 hour and 30 minutes is used for the CRUD web application practical. Here, candidates are expected to build an application that can create, display, update, and delete product-related information using a suitable technology stack.
Therefore, the technical/programming interview and CRUD practical together take 3 hours. Since both programming and practical development are important parts of this round, candidates should prepare for coding problems as well as basic full-stack application development.
With the interview structure clear, let’s move on to the programming problems shared by the trainees, starting with Set 1.
SET 1: Programming Questions
The programming section is an important part of the Secure IT technical interview. The questions shared by the Payilagam trainees cover different problem-solving areas such as arrays, strings, hash-based approaches, and matrices.
These problems are useful for checking how well a candidate understands basic programming logic and how effectively they can convert that logic into working code. For candidates preparing with Java, it is also important to understand the approach instead of memorizing the solution.
The first set contains five programming questions. We will go through each problem step by step, starting with a simple explanation of the question and then looking at the Java solution.
1. Remove Duplicates from Sorted Array – #26
Input: nums = [1,1,2]
Output: 2, nums = [1,2,_]
Explanation: Your function should return k = 2, with the first two elements of nums being 1 and 2 respectively.
It does not matter what you leave beyond the returned k (hence they are underscores).
class Solution {
public int removeDuplicates(int[] nums) {
if (nums.length == 0) {
return 0;
}
int k = 1;
for (int i = 1; i < nums.length; i++) {
if (nums[i] != nums[k - 1]) {
nums[k] = nums[i];
k++;
}
}
return k;
}
}2. Two Sum – #1
Input: nums = [2,7,11,15], target = 9
Output: [0,1]
Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].
import java.util.HashMap;
class Solution {
public int[] twoSum(int[] nums, int target) {
HashMap<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
int required = target - nums[i];
if (map.containsKey(required)) {
return new int[] {map.get(required), i};
}
map.put(nums[i], i);
}
return new int[] {};
}
}3. Group Anagrams – #49
Input: strs = ["eat","tea","tan","ate","nat","bat"]
Output: [["bat"],["nat","tan"],["ate","eat","tea"]]
Explanation:
There is no string in strs that can be rearranged to form "bat".
The strings "nat" and "tan" are anagrams as they can be rearranged to form each other.
The strings "ate", "eat", and "tea" are anagrams as they can be rearranged to form each other.
import java.util.*;
class Solution {
public List<List<String>> groupAnagrams(String[] strs) {
Map<String, List<String>> map = new HashMap<>();
for (String str : strs) {
char[] chars = str.toCharArray();
Arrays.sort(chars);
String key = new String(chars);
map.putIfAbsent(key, new ArrayList<>());
map.get(key).add(str);
}
return new ArrayList<>(map.values());
}
}
4. Product of Array Except Self - #238
Input: nums = [1,2,3,4]
Output: [24,12,8,6]
The Product of Array Except Self problem is another array-based question that tests how well you can work with values at different positions in an array. The task is to create a new array where each position contains the product of all the numbers in the original array except the number at that same position.
class Solution {
public int[] productExceptSelf(int[] nums) {
int n = nums.length;
int[] result = new int[n];
result[0] = 1;
// Store the product of all elements to the left
for (int i = 1; i < n; i++) {
result[i] = result[i - 1] * nums[i - 1];
}
// Multiply with the product of all elements to the right
int rightProduct = 1;
for (int i = n - 1; i >= 0; i--) {
result[i] = result[i] * rightProduct;
rightProduct *= nums[i];
}
return result;
}
}5. Rotate Image – #48
Input: matrix = [[1,2,3],[4,5,6],[7,8,9]]
Output: [[7,4,1],[8,5,2],[9,6,3]]
class Solution {
public void rotate(int[][] matrix) {
int n = matrix.length;
// Transpose the matrix
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
int temp = matrix[i][j];
matrix[i][j] = matrix[j][i];
matrix[j][i] = temp;
}
}
// Reverse each row
for (int i = 0; i < n; i++) {
int left = 0;
int right = n - 1;
while (left < right) {
int temp = matrix[i][left];
matrix[i][left] = matrix[i][right];
matrix[i][right] = temp;
left++;
right--;
}
}
}
}
Image Courtesy: https://leetcode.com/
Input: matrix = [[1,2,3],[4,5,6],[7,8,9]]
Output: [[7,4,1],[8,5,2],[9,6,3]]
class Solution {
public void rotate(int[][] matrix) {
int n = matrix.length;
// Transpose the matrix
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
int temp = matrix[i][j];
matrix[i][j] = matrix[j][i];
matrix[j][i] = temp;
}
}
// Reverse each row
for (int i = 0; i < n; i++) {
int left = 0;
int right = n - 1;
while (left < right) {
int temp = matrix[i][left];
matrix[i][left] = matrix[i][right];
matrix[i][right] = temp;
left++;
right--;
}
}
}
}SET 2: Programming Questions
The first set covered problems involving arrays, strings, and matrices. The second set continues with more programming questions that test different types of problem-solving skills.
These questions include string manipulation, backtracking, searching within a string, and finding the frequency of elements in an array. Understanding the basic logic behind each problem is more important than simply remembering the code.
Let’s begin the second set with a problem that uses the numbers on a phone keypad to generate all possible letter combinations.
1. Letter Combinations of a Phone Number – #17
Image Courtesy: https://leetcode.com/
Input: digits = "23"
Output: ["ad","ae","af","bd","be","bf","cd","ce","cf"]
import java.util.*;
class Solution {
public List<String> letterCombinations(String digits) {
List<String> result = new ArrayList<>();
if (digits == null || digits.length() == 0) {
return result;
}
String[] phone = {
"", "", "abc", "def", "ghi",
"jkl", "mno", "pqrs", "tuv", "wxyz"
};
backtrack(digits, 0, new StringBuilder(), result, phone);
return result;
}
private void backtrack(String digits, int index,
StringBuilder current,
List<String> result,
String[] phone) {
if (index == digits.length()) {
result.add(current.toString());
return;
}
String letters = phone[digits.charAt(index) - '0'];
for (char letter : letters.toCharArray()) {
current.append(letter);
backtrack(digits, index + 1, current, result, phone);
current.deleteCharAt(current.length() - 1);
}
}
}2. Reverse Words in a String – #151
Input: s = "the sky is blue"
Output: "blue is sky the"
class Solution {
public String reverseWords(String s) {
String[] words = s.trim().split("\\s+");
StringBuilder result = new StringBuilder();
for (int i = words.length - 1; i >= 0; i--) {
result.append(words[i]);
if (i != 0) {
result.append(" ");
}
}
return result.toString();
}
}3. Find the Index of the First Occurrence in a String – #28
Input: haystack = "sadbutsad", needle = "sad"
Output: 0
Explanation: "sad" occurs at index 0 and 6.
The first occurrence is at index 0, so we return 0.
The Find the Index of the First Occurrence in a String problem checks whether one string is present inside another string. If it is found, the program should return the index where the first occurrence starts. If it is not found, the result should be -1.
class Solution {
public int strStr(String haystack, String needle) {
int n = haystack.length();
int m = needle.length();
if (m == 0) {
return 0;
}
for (int i = 0; i <= n - m; i++) {
int j = 0;
while (j < m && haystack.charAt(i + j) == needle.charAt(j)) {
j++;
}
if (j == m) {
return i;
}
}
return -1;
}
}4. Permutations – #46
Input: nums = [1,2,3]
Output: [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
import java.util.*;
class Solution {
public List<List<Integer>> permute(int[] nums) {
List<List<Integer>> result = new ArrayList<>();
backtrack(nums, new ArrayList<>(), result);
return result;
}
private void backtrack(int[] nums, List<Integer> current,
List<List<Integer>> result) {
if (current.size() == nums.length) {
result.add(new ArrayList<>(current));
return;
}
for (int num : nums) {
if (current.contains(num)) {
continue;
}
current.add(num);
backtrack(nums, current, result);
current.remove(current.size() - 1);
}
}
}5. Count/Frequency of Elements in an Array – #3005
Input: nums = [1,2,2,3,1,4]
Output: 4
Explanation: The elements 1 and 2 have a frequency of 2 which is the maximum frequency in the array.
So the number of elements in the array with maximum frequency is 4.
The final programming question in Set 2 focuses on finding the frequency of elements in an array. Here, frequency means the number of times a particular value appears in the array.
The task is to find the maximum frequency and then count how many elements have that same maximum frequency.
import java.util.HashMap;
import java.util.Map;
class Solution {
public int maxFrequencyElements(int[] nums) {
Map<Integer, Integer> frequency = new HashMap<>();
// Count the frequency of each element
for (int num : nums) {
frequency.put(num, frequency.getOrDefault(num, 0) + 1);
}
int maxFrequency = 0;
// Find the maximum frequency
for (int count : frequency.values()) {
maxFrequency = Math.max(maxFrequency, count);
}
int result = 0;
// Count elements having the maximum frequency
for (int count : frequency.values()) {
if (count == maxFrequency) {
result += count;
}
}
return result;
}
}
CRUD Web Application: Practical Question
Build a web application/website to perform CRUD operations for product details:
After completing the programming questions, the next part of the Secure IT interview focuses on practical application development. In this task, candidates are expected to build a web application that can perform basic CRUD operations for product details.
CRUD stands for:
- Create – Add new product information.
- Read – Display the available product information.
- Update – Edit existing product information.
- Delete – Remove a product from the application.
The main goal of this practical task is to check whether the candidate can connect different parts of a web application and make them work together. This includes creating the user interface, handling the application logic, and storing the information in a SQL database.
Candidates can choose either of the following technology options based on the skills they are comfortable with.
Option 1: HTML + CSS + JavaScript + React + Java + SQL
In this option, HTML, CSS, JavaScript, and React can be used to build the frontend. Java can handle the backend operations, while SQL is used to store and manage the product information.
Option 2: HTML + CSS + JavaScript + Node.js + SQL
In the second option, the frontend can be developed using HTML, CSS, and JavaScript, while Node.js is used for the backend. The product information is stored in a SQL database.
Note: From the above, the interviewee can choose any one option.
Database Structure
Table 1: products
| Column | Data Type |
| id | INT |
| product_name | VARCHAR(100) |
Table 2: product_brands
| Column | Data Type |
| id | INT |
| product_name | VARCHAR(100) |
| brand | VARCHAR(50) |
Table 3: product_details
| Column | Data Type |
| id | INT |
| product_name | VARCHAR(100) |
| brand | VARCHAR(50) |
| price | DECIMAL(10,2) |
Sample Output
Table 1: Products
| Product Name | Action |
| TUF A15 | Edit / Delete |
| Inspiron 15 | Edit / Delete |
| ThinkPad E14 | Edit / Delete |
| Pavilion 15 | Edit / Delete |
Table 2: Products & Brands
| Product Name | Brand | Action |
| TUF A15 | ASUS | Edit / Delete |
| Inspiron 15 | Dell | Edit / Delete |
| ThinkPad E14 | Lenovo | Edit / Delete |
| Pavilion 15 | HP | Edit / Delete |
Table 3: Product Details
| Product Name | Brand | Price | Action |
| TUF A15 | ASUS | ₹65,000 | Edit / Delete |
| Inspiron 15 | Dell | ₹58,000 | Edit / Delete |
| ThinkPad E14 | Lenovo | ₹72,000 | Edit / Delete |
| Pavilion 15 | HP | ₹55,000 | Edit / Delete |
Edit / Update Example
Initial: TUF A15 | ASUS | ■65,000 | Edit | Delete
After editing: TUF A15 | ASUS | ■70,000 | Update
After Update: TUF A15 | ASUS | ■70,000 | Edit | Delete
Delete Example: Clicking Delete removes the selected row and displays the updated table.
Final Thoughts
Preparing for an interview becomes easier when you understand the type of questions and practical tasks that can be asked. The Secure IT interview experience shared by Payilagam trainees includes programming problems, technical discussions, and a CRUD web application practical. Practising these areas can help candidates improve their problem-solving skills and become more comfortable with real interview tasks.
The programming questions covered in this article also show why it is important to practise different types of problems. Array questions can improve logical thinking, string problems can strengthen basic programming skills, and backtracking questions can help candidates understand how to handle multiple possible solutions. Along with coding, candidates should also practise building simple applications and connecting them with a database.
For candidates looking to build a career in software development, choosing the right training and practising through real projects can make a difference. Payilagam focuses on helping learners gain practical knowledge that they can use while preparing for technical interviews and their first software job.
If you are looking for the Best Software Training Institute in Chennai, focus on learning the concepts, building projects, practising coding questions, and preparing for interviews step by step.
Learn! Build! Get Hired!
You can also strengthen your Java programming and development skills through a structured Best Java Training in Chennai program, especially if Java is the technology you want to use for backend development and technical interviews.
Remember, interview preparation is not only about knowing the answers. It is about understanding the logic, writing clean code, explaining your approach, and showing that you can build something that works. Start practising consistently and use every interview question as an opportunity to improve your skills.
