Appifylab Trainee Software Engineer Interview Experience

Disclaimer: This is my personal interview experience at Appifylab. Hiring processes, assessments, and interview rounds may change over time. I am sharing this article to help students, fresh graduates, and junior developers understand what they might encounter during a software engineering hiring process.

Getting your first software engineering job can be confusing.

You may know programming, solve problems on online judges, build projects, and still have no idea what an actual company's hiring process looks like.

I was in the same situation when I applied for a Trainee Software Engineer position at Appifylab.

The process was more practical than I initially expected. It included a CV screening, a programming contest, a long web development assessment, and finally an interview with the company's leadership.

Thankfully, I successfully passed all the stages and received an offer.

In this post, I will explain the process step by step, what I worked on, what I could and couldn't complete, and what I would recommend to someone preparing for a similar opportunity.

My Appifylab Interview Process at a Glance

My hiring process had three major stages:

1. CV Screening
2. Programming Contest - 4 hours
3. Web Development Assessment - 8 hours
4. Final Interview with the CGO

The first stage was not an interview. My CV was screened first, and candidates who moved forward were invited to the programming contest.

The programming contest was divided into morning and evening batches.

I participated in the morning batch.

Round 1: CV Screening

The first step was submitting my CV.

Like most software engineering hiring processes, the CV is important because it is the first thing the company sees before deciding whether to move you to the next stage.

For a junior or trainee software engineer position, I believe your CV should make these things easy to identify:

• Programming languages you know
• Frameworks and technologies you have used
• Software projects
• GitHub profile
• Competitive programming experience
• Education
• Relevant achievements
• Internship or professional experience, if any

For fresh graduates, you don't necessarily need years of professional experience.

Your projects and problem-solving experience can demonstrate that you can actually build things and solve problems.

My advice for the CV

Don't try to put every technology you've ever touched on your CV.

Instead, focus on technologies you can actually explain.

For example, if your CV says:

React, Node.js, MySQL, REST API

you should be comfortable answering questions about all of them.

A short, honest CV is much better than a huge list of technologies that you barely know.

Round 2: Programming Contest

After the CV screening, the next stage was a 4-hour programming contest.

The contest was conducted in two batches:

• Morning batch
• Evening batch

I participated in the morning batch.

The contest was hosted on Vjudge and contained seven problems.

The important thing I learned from this round is that knowing basic syntax is nowhere near enough for a software engineering coding test.

You need to be comfortable with:

• Arrays
• Strings
• Searching
• Sorting
• Binary search
• Data structures
• Number theory
• Dynamic programming
• Trees
• Range queries
• Time complexity

You don't necessarily need to solve every advanced problem, but you should be able to quickly identify the easier problems and collect those points first.

Morning Batch Problems

These were the problems in my batch.

1. Can You Help?

Can You Help?

This problem involved a grid and determining whether the marked cells formed a valid straight line before calculating the required result.

Topics: Implementation, Strings/Grid

2. Min Value

Min Value

The problem gives an array and multiple queries. For every query, you need to find the minimum absolute difference between the query value and an element of the array.

Topics: Sorting, Binary Search

This is a good example of why understanding complexity matters.

With large N and Q, checking every array element for every query would be too slow.

3. Shine on You Crazy Diamond

Shine on You Crazy Diamond

This was a number-theory-oriented problem where you perform two operations that remove multiples of selected values and minimize the remaining array size.

Topics: Number Theory

4. Subarray Sum

Subarray Sum

The problem asks you to select at most K positions and replace their values with zero so that the maximum possible subarray sum is maximized.

Topics: Dynamic Programming, Data Structures

5. Aloyna and Can Buying

Aloyna and Can Buying

Given different types of cans, you need to determine which type occurs the most. If multiple types have the same maximum frequency, the smallest type number wins.

Topics: Implementation, Sorting

6. Data Structure

Data Structure

This problem asks you to maintain a collection with update operations and queries for the B-th smallest element.

Topics: Data Structures, Order Statistics

7. Another String Query Problem

Another String Query Problem

This was one of the more advanced problems. It involves strings, ranges, longest common prefixes, and maximizing a value based on the LCP between strings.

Topics: Strings, LCP, Data Structures

Evening Batch Problems

The evening batch had a different set of problems.

1. Subsegment Search

Subsegment Search

This problem involves finding how many times one array appears as a subsegment of another, with an allowed constant adjustment to all elements of the second array.

Topics: Arrays, Pattern Matching, KMP

2. Largest Prime

Largest Prime

For each query, you need to find the largest prime number within a given range.

Topics: Binary Search, Math, Number Theory

3. Magic Prime

Magic Prime

This problem involves prime factorization, exponents, modular arithmetic, and properties of the number of divisors.

Topics: Number Theory, Modular Arithmetic

4. Exists or Not Exists

Exists or Not Exists

For each query, you need to determine whether a particular number exists inside a specified range of an array.

Topics: Binary Search, Segment Tree, Data Structures

5. Tree Queries

Tree Queries

This problem involves answering queries about values inside the subtree of a given tree vertex.

Topics: Trees, DFS, Fenwick Tree, Data Structures

6. Alphabet Animals

Alphabet Animals

A word-game problem where the next animal name has to start with the last character of the previous animal name, with additional conditions for eliminating the next player.

Topics: Strings, Implementation

7. The Punishment

The Punishment

This was the final problem of the evening batch.

How I Approached the Programming Contest

The biggest mistake you can make in a programming contest is spending the entire contest on one difficult problem.

With a four-hour limit, time management matters almost as much as problem-solving ability.

My recommended strategy is:

Step 1: Read everything first

Don't immediately start coding after opening the first problem.

Spend some time looking through all the problems.

Identify:

• Problems you immediately understand
• Problems that look like implementation
• Problems requiring a familiar algorithm
• Problems that look significantly harder

Step 2: Solve the easiest problems first

Get the straightforward problems out of the way.

This gives you:

• Accepted submissions
• Confidence
• More time for difficult problems

Step 3: Don't get emotionally attached to one problem

If you have spent 30–40 minutes going nowhere, move on.

Come back later with a fresh perspective.

Step 4: Always think about complexity

Before submitting, ask yourself:

"What happens when N = 100000?"

An O(N²) solution might work for N = 1000 but completely fail for N = 100000.

Understanding constraints is one of the most important skills for competitive programming.

Round 3: 8-Hour Web Development Assessment

After the programming contest, selected candidates moved to the next stage.

This was very different from the programming contest.

Instead of solving isolated algorithmic problems, we were given an existing web project.

The company provided an HTML/CSS ZIP file containing a social-platform-style website.

The task was essentially to turn that static frontend into a functional application using:

• React
• Node.js
• MySQL

The assessment duration was 8 hours.

This was probably the most interesting part of the process for me because it was much closer to actual software development.

What Was Required in the Web Assessment?

The provided project already had the HTML and CSS.

The challenge was to take that design and build the actual application around it.

The expected direction was roughly:

HTML/CSS Design
       ↓
     React
       ↓
    Node.js
       ↓
     MySQL

So instead of simply creating a UI, we had to think about:

• Frontend components
• React state
• API design
• Backend logic
• Database structure
• CRUD operations
• Connecting frontend and backend
• Making the application functional

This is very different from solving a single competitive programming problem.

What I Managed to Complete

I want to be honest about this part because this is probably the most useful information for someone preparing for a similar assessment.

I did not complete the entire assessment.

Within the eight-hour time limit, I managed to:

• Convert the provided frontend into React
• Build the post-related functionality
• Allow users to create posts
• Connect the relevant frontend functionality with the backend

The post functionality was the main part I was able to complete.

There were still other parts of the social platform that I couldn't finish within the assessment time.

And that's okay.

One of the biggest lessons I learned from this assessment was that an assessment doesn't always measure whether you can finish 100% of the requirements.

It can also show:

• How you structure your work
• How you prioritize features
• How you approach an unfamiliar codebase
• How quickly you can build
• Whether you understand the technologies you're using
• Whether your implementation is functional

How I Would Prepare for an 8-Hour Web Assessment Now

If I had to take the same assessment again, I would prepare differently.

I would practice building a small full-stack application from scratch.

For example:

React
   ↓
REST API
   ↓
Node.js / Express
   ↓
MySQL

I would make sure I could quickly implement:

Authentication

• Register
• Login
• Password hashing
• JWT/session handling

CRUD

• Create
• Read
• Update
• Delete

Social features

• Create post
• Edit post
• Delete post
• Like post
• Comment
• User profile

Database

Understand how to quickly create tables such as:

users
posts
comments
likes

API

Be comfortable designing endpoints such as:

POST   /api/posts
GET    /api/posts
GET    /api/posts/:id
PUT    /api/posts/:id
DELETE /api/posts/:id

You don't need to build Facebook in eight hours.

You need to know how to build a small, functional version of the required features quickly.

A Very Important Lesson: Prioritize Functionality

If you receive an eight-hour assessment, don't spend the first four hours making everything beautiful.

A functional application is more valuable than a beautiful application with no working backend.

I would divide the time roughly like this:

The exact timing obviously depends on the assignment.

The main idea is:

Build the core functionality first. Polish later.

Final Round: Interview With the CGO

After the web assessment, the selected candidates moved to the final stage.

The final interview was with the CGO of the company.

At this point, the process moved away from pure coding and became more of a conversation about the candidate.

This stage is important because a company isn't only hiring someone who can solve programming problems.

They are hiring someone they will actually work with.

So I would prepare for questions around:

• Tell me about yourself
• Your education
• Your projects
• Your previous experience
• Why software engineering?
• Why do you want to join the company?
• What technologies do you know?
• What are you currently learning?
• Your career goals
• How do you handle difficult problems?
• How do you work with a team?
• Where do you see yourself in a few years?

Most importantly, know your own CV.

If you mention something on your CV, be prepared to explain it.

And Finally — I Got the Offer

After going through the entire process, I successfully received the offer.

That made the whole experience especially meaningful because the process itself was challenging.

I didn't solve everything.

I didn't finish the entire web assessment.

But I was able to demonstrate my problem-solving ability, development skills, and potential.

And that was enough to move forward.

What I Learned From the Appifylab Interview Process

Looking back, there are several lessons I would give to anyone preparing for their first software engineering job.

1. Competitive programming still matters

You don't need to be a Grandmaster.

But you should be comfortable with:

• Arrays
• Strings
• Sorting
• Binary search
• Basic data structures
• Complexity analysis
• Basic graph/tree concepts
• Common algorithms

Regular practice makes a huge difference.

2. Don't ignore development skills

Competitive programming and software development are two different skill sets.

You can be good at solving algorithmic problems but struggle to build a real application.

And you can be a good developer without being exceptional at competitive programming.

For junior software engineering roles, I recommend developing both.

3. Learn to build without tutorials

This is extremely important.

During an assessment, you don't have someone explaining every step.

You need to be able to think:

"I need a post creation feature. What database table do I need? What API should I create? What should the React component look like? How should the frontend communicate with the backend?"

That ability comes from building projects yourself.

4. Learn the fundamentals before frameworks

Don't only learn:

"How to create a React component."

Understand:

• HTTP
• REST APIs
• Request/response
• HTTP methods
• Databases
• SQL
• Authentication
• CRUD
• Client-server architecture
• Asynchronous programming

Frameworks change.

Fundamentals stay.

5. Practice under time pressure

An eight-hour assessment feels very different from building a project over two weeks.

Set a timer.

Give yourself 4–8 hours.

Then try to build something functional.

This will teach you how to prioritize.

My Recommended Preparation Roadmap for Freshers

If you're a university student or a recent graduate preparing for a similar software engineering hiring process, I would follow this roadmap.

Competitive Programming

Practice:

Arrays
Strings
Sorting
Binary Search
Two Pointers
Prefix Sum
Stack
Queue
Map / Set
Recursion
Greedy
Dynamic Programming
Trees
Graphs
Basic Number Theory

You don't need to master everything before applying.

But you should have a solid foundation.

Web Development

Build at least one complete full-stack project.

For example:

React
    +
Node.js
    +
MySQL/PostgreSQL

Make sure it has:

• Authentication
• CRUD
• REST API
• Database relationships
• Validation
• Error handling
• Git/GitHub

Projects

Don't just follow a YouTube tutorial.

After completing a tutorial, close it and rebuild the project yourself.

That is where the real learning happens.

Final Thoughts

The Appifylab hiring process taught me that getting a software engineering job isn't about being perfect at one thing.

You need a combination of:

Problem solving + Development skills + Fundamentals + Communication + Ability to learn

The programming contest tested how I solve algorithmic problems.

The web assessment tested whether I could build something practical under time pressure.

The final interview tested me as a person and as a potential teammate.

And ultimately, I was fortunate enough to pass the process and receive the offer.

If you're preparing for your first software engineering job, don't wait until you see a job posting to start preparing.

Start building.

Start solving problems.

Start reading other people's code.

And most importantly, build things without someone holding your hand through every step.

That's what helped me the most.

Useful Resources

Programming Contest

The problems from my programming contest are available on Toph:

Morning batch

• Can You Help?
• Min Value
• Shine on You Crazy Diamond
• Subarray Sum
• Aloyna and Can Buying
• Data Structure
• Another String Query Problem

Evening batch

• Subsegment Search
• Largest Prime
• Magic Prime
• Exists or Not Exists
• Tree Queries
• Alphabet Animals
• The Punishment

About Appifylab

Appifylab is a software company based in Bangladesh that builds digital products and SaaS platforms. Its products include EzyCourse, EzyCommunity, EzyStudio and other platforms. The company currently lists its head office in Sylhet.

For the latest information about vacancies and the company's hiring process, always check the official Appifylab Careers page.

About Me

I'm Md. Mehedi Hasan, a software engineer from Bangladesh.

I enjoy building software, solving programming problems, and learning new technologies.

You can find more about my work and projects on my portfolio.

If you're preparing for a similar software engineering interview, I hope this experience helps you prepare a little better. Good luck!