Full Stack Developer Interview Questions and Answers

It’s an abbreviation for “frontend/backend/database”. In order to understand the meaning of the term, it is necessary to consider the following three components: (frontend, backend, and database) are all essential parts of any modern website or app.

• Knowledge of programming languages such as PHP, Python, Ruby, Javascript, C#, etc.
• Understanding of server technologies like Linux, Apache, MySQL, Nginx, Memcached, Redis, and more.
• Experience using Git and Github.
• Understand the basics of databases like SQLite, Postgres, MongoDB, Couchbase, and others.

• Model View Controller is a design pattern used by most developers when creating applications.
• It separates the logic of the application into different layers.
• Each layer has its own responsibilities and can be reused across multiple projects.
• In other words, the model contains business logic, while the view displays information to the user.
• Finally, the controller deals with sending requests to the model, receiving responses, and then displaying them on the screen.

• MVP stands for Model View Presenter.
• It is a way to create better, more maintainable, and easier to test applications.
• With MVP, you don’t need to write unnecessary boilerplate code to make things happen between the view and the presenter.
• Instead, you focus on writing clean code that works.

1. MVC is a design pattern where each component plays a specific role.

For example, the model is responsible for storing data, the view displays data to the user, and the controller sends requests to the model and receives responses from the model.

2. On the other hand, MVP is a pattern that focuses on separating the presentation layer from the rest of the application.

This means that the view doesn’t interact directly with the model; instead, it interacts with the presenter.

• You can easily reuse the same view and presenter across multiple projects.
• It’s easy to add new views without having to change existing ones.
• You can easily swap out the presenter if you want to switch to another framework.
• You can easily swap in a new presenter if you decide to implement a new feature.

• You can write the entire application in one language. This makes it very simple to understand what is going on behind the scenes.
• Presentation and business logic can be separated. Due to this, the code is more organized and easier to read as a result.
• It’s easy to add new controllers.
• You can quickly switch between different UI frameworks.

The main advantage of MVP over MVC is that it allows you to reuse your view and presenter.

If you have a single page application with lots of pages, this could save you a lot of time.

However, if you’re building a mobile app, it might not be as beneficial because there will always be some kind of navigation involved.

A Model View Controller (MVC) is a software architecture paradigm that separates user interface logic from application business logic. On the other hand, Model-View-ViewModel (MVVM) is a framework that makes your UI more responsive and easy to maintain.

Pair Programming is a form of collaborative software development where two developers work simultaneously on the same computer system. This allows both programmers to see what each other is doing, and therefore reduce errors and improve quality.

The programmer who writes the code is known as the Driver and the programmer who reviews (checks code etc.) the code is known as Navigator.

Pair programming is most often used in Agile Software Development Methodologies such as Scrum and Kanban. In fact, some people say that Scrum is just one way of implementing pair programming.

• Cross-Origin Resource Sharing (CORS) is a mechanism that enables web browsers to send cross-domain XML Http Requests.
• The browser checks whether or not the request is allowed by looking at the Access-Control-Allow-Origin header value sent by the server. If the response contains an Origin header, then the browser knows that the request was made using JavaScript.
• This prevents malicious websites from stealing information from other sites.

• IoC is a design principle that states that objects should only depend upon abstractions, and not upon specifics.
• An object depends on something else when it needs to get access to it.
• This allows us to test our classes independently.

Dependency injection is a technique that allows you to pass dependencies into your constructor instead of having them passed in through the arguments.

• With dependency injection, we don’t need to create instances of these dependencies ourselves.
• We can use interfaces instead of concrete implementations.

Inversion of control is a design pattern that says “pass any object into my class” rather than passing specific objects into my class.

• It’s much easier to change the implementation of the dependency later on.
• You can unit test classes without needing to mock their dependencies.

• Continuous integration is a practice of automating the process of testing and deploying software.
• It helps teams to build better software faster.
• It makes sure all changes go smoothly.

Continuous integration is a coding philosophy that encourages building software in small increments often called “deliverables.” This approach allows teams to build, test, and deploy multiple versions of an app simultaneously. A good example of this would be a team working on a mobile app where each version is tested on different devices.

The term “continuous delivery” refers to the process of releasing those deliverables into production. In some cases, you might see the terms combined into one word such as “continuous delivery”.

A continuous integration and delivery pipeline is a software development process in which the build and deployment pipelines are integrated together. This means that whenever a developer commits his code, the build server automatically runs unit tests and builds the app. Then, the deployer checks whether the app is working properly. If yes, he pushes the app to production. Otherwise, he rolls back the changes and tries again.

REST stands for Representational State Transfer. RESTful web services are stateless.

• A RESTful web service uses HTTP methods like GET, POST, PUT, DELETE, etc.
• RESTful web services return data in XML format.
• RESTful web services follow the HATEOAS principle.

• The GraphQL query language is used to communicate with databases.
• GraphQL is a type of API that uses queries to retrieve information from a database.
• The goal of GraphQL is to make APIs more intuitive by allowing developers to ask questions about what they want to know.

A graphQL query language is a query language for APIs that uses expressions to specify what requests your app needs and how the data should be returned. REST, on the other hand, is an protocol used to design systems where resources are exposed as URLs over HTTP. These URLs can be accessed by clients using any web browser or application and do not require extra libraries or tools.

We can use the following ways of enhancing the scalability and efficiency:

• Avoiding URL redirects – Redirects are one of the most common methods used to improve site performance. But there are some drawbacks to it. They cause extra load on the server because they must process requests twice. Also, redirects take longer to complete than static resources like CSS files or HTML documents.
• Avoiding duplicate codes – Duplicate code refers to identical chunks of code being repeated across multiple pages. This causes additional load on the server because each request requires loading the same resource again. In addition, duplicate code increases the size of the file.
• Avoiding unnecessary images – Images are great for adding visual interest to webpages. However, large images require more bandwidth and storage space than smaller ones. If you don’t need an image, consider using a tool like TinyPNG to reduce the size without losing quality.
• Leveraging browser caching – Browser caching allows us to store frequently accessed resources locally rather than fetching them every time a visitor visits our website. This reduces the amount of data we need to serve to visitors and improves overall speed.
• Deferring parsing of Javascript – When a webpage loads, it parses the HTML document into individual elements and creates DOM objects. These objects allow us to access information about the structure of the page and interact with the page. For example, we might want to change the color of certain parts of the page. To do this, we’d need to find those parts of the document and manipulate them individually. Instead, we could defer the parsing of the document until later. Once the document is parsed, we can access the desired elements directly.

The get request is a GraphQL operation used to get data from the server. It takes an input type of Item and a query expression as arguments. The output of this request will be an Item instance that represents the data you requested from the server.

Post request is a method of submitting new messages to a remote system. It is the second stage of a GraphQL query. It’s executed when the client sends an HTTP post request to the server.

Put request is a method of updating existing messages in a remote system.

Delete request is a method of deleting messages from a remote system.

Retrieving information from a web server is done using the GET method. This request type is used to return static resources such as HTML files, images, and CSS stylesheets, as well as JavaScript code. In addition, it is used to make asynchronous requests without waiting for a response.

Data is sent to a web server using the POST method. In most cases, the request is sent via a form. However, there are many situations where you want to send data to a remote server without having to use a form. For example, you might want to submit data directly from a script running on a local machine. You could also use the POST method to upload files to a remote server.

Strict mode is a feature that helps prevent common programming mistakes by forcing developers to write their programs correctly. Strict mode disallows some features of JavaScript, including:

• The use of eval() or Function constructor.
• The creation of global variables.
• The use of undeclared functions.

Advantages – “Use strict” is a statement that is usually placed at the beginning of every script to enable strict mode to the whole script. This makes it impossible to accidentally use global variables or make assignments that would otherwise silently succeed to assign null to something else. It makes attempts to delete undeletables properties throw where before the attempt would just have no effect.

Disadvantage – “Strict” mode is a way to turn off some features of JavaScript. For example, you might want to disable automatic semicolon insertion, or even restrict the kinds of things you can do with objects.

• Git pull is a command which pulls changes made to a repository (usually a version control software like git).
• A repository is a collection of source code stored online.
• Source code is the original code written by programmers.
• Changes made to the source code are called commits.
• Commits are stored in a database so they can be retrieved easily.

• Git fetch is a command which downloads all the latest updates from another repository.
• Repositories are places where your code is stored.
• Code is the actual program written by programmers.
• Updates are changes made to the code.
• Updating means downloading the latest changes from the repository.

Long polling is a pattern in web application design where the server keeps a long-held connection with the client and sends messages continuously without waiting for the client to send any requests. This allows the server to push data to the client even though there are no active requests.

JavaScript is a language which runs in browsers while TypeScript is a superset of JavaScript and compiles down to JavaScript.

In my opinion, most would agree that both are ways to implement a modular architecture. However, there are some key differences between the two approaches. Let’s take a look at what makes each approach unique and why it might be better suited for certain situations.

CommonJS- The CommonJS specification defines a way to organize your code into separate files and load them together into a single application. This allows you to reuse common functionality across multiple applications without having to rewrite everything again and again. You can use CommonJS to build single-page apps, web servers, desktop applications, mobile applications, etc.

AMD- AMD is a specification for defining how to load JavaScript modules. Its goal is to make sure that modules loaded in different parts of an application don’t interfere with each other. For example, if you want to load jQuery once in the browser and another version of jQuery in your server-side code, you can do that easily with AMD.

So, which approach is best for me?

That depends on your situation. If you’re building a single-page app, you probably won’t need to worry about the difference between CommonJS and AMD. But if you plan to deploy your application to a server, you’ll definitely want to use AMD.

Callback Hell, or Pyramid of doom, is a common anti pattern seen in asynchronous programming code. This slang term describes a situation where there are multiple asynchronous functions dependent on each other. These functions depend on one another so it gets very messy with so many callbacks nestled within so many layers. You end up having code that is difficult to understand and maintain, and looking like a pyramid as shown above.

This is because it is hard to see the flow of the application and debug issues. This is why we have the famous name for this problem: Callback hell.

Docker is a tool that helps developers create containers. A container is basically a virtual machine that runs inside a host operating system. It provides isolation from other processes running on the same computer.

Developers can use Docker to isolate their applications from their infrastructure. This allows them to deploy the same version of an app to every server they want without worrying about differences in hardware or software.

The most common tool used by developers to test their code is called Unit Testing. It helps them to ensure that they have not made any mistakes while coding. They can also run these tests on different browsers or devices to make sure that their code works across all platforms.

Yes, I am very familiar with design patterns. Design patterns are reusable components which allow us to write better code. These patterns help us to reduce the amount of code written and increase its readability.

Both management and execution are important parts of being a good manager. You need to be able to manage people and resources efficiently. At the same time, you need to be able to execute tasks quickly and accurately.

• Automation – Automating processes saves time and money.
• Quality Assurance – Ensuring quality at every stage of the project.
• Documentation – Documenting everything so that others can understand what has been done.
• Communication – Communicating clearly and concisely with everyone involved.
• Feedback – Getting feedback from clients and users about what needs to change.
• Version Control – Keeping track of changes and making sure that nothing gets lost.
• Code Review – Checking other’s code before submitting it.
• Test Driven Development (TDD) – Writing automated tests first then writing the actual code.
• Agile Methodology – Using an agile methodology like Scrum where there is constant collaboration between the team members.

In object oriented programming, when two objects share some properties but don’t necessarily share methods, we call it bridge pattern. For example, if we want to create a new class that inherits from another class, we would use bridge pattern.

GitFlow is a branching model developed by GitHub. It allows developers to keep their source code organized into branches. Branches are created based on feature requests or bug fixes. The entire team reviews a branch before it can be merged into master, and it is thoroughly tested before being merged into master. If no issues are found, the branch is merged into master.

Arrow function is a syntactic sugar for creating anonymous functions. The syntax looks like a normal function declaration except for the fact that the body of the function is wrapped in parentheses instead of curly braces.

some cases are:

• When you have to pass parameters to the function.
• When you need to return something from the function.
• When you need to access variables defined outside the function.
• When you need to capture values returned by the outer function.

• Create a folder called lib inside your src directory.
• Put all the shared code inside the lib folder.
• Import the file using require() statement.
• Use exports keyword to export the module.
• Use import statement to import the module.

Directive is a way to add custom behavior to HTML tags. They allow us to extend HTML with our own rules without having to modify the core HTML.

Component is a reusable piece of UI which encapsulates its logic and state. Components are usually built using React or Angular.

• Directives are attached to DOM nodes while components are attached to views.
• A directive is associated with a single tag whereas a component is associated with multiple tags.
• A directive is an extension to the HTML language whereas a component is an abstraction over HTML.

In addition to being built on Chrome’s JavaScript runtime, Node.js also allows you to create fast and scalable network applications with ease by taking advantage of its JavaScript architecture.

Express.js is a web application framework written in node.js. It provides a robust set of features for developing RESTful web services.

Socket.IO is a real-time communication library for Node.js. It uses WebSockets under the hood and works well with other libraries such as express.js.

MongoDB is a NoSQL database designed to handle large amounts of data across many machines. It stores documents, each containing key/value pairs.

Redis is a open source, advanced key-value store. It supports persistence, transactions, clustering, replication, high availability, and automatic scaling.

As an open-source system, Kubernetes enables you to deploy, manage, and monitor containerized applications in a simple, automated manner.

With Ansible, you can automate repetitive tasks by using a configuration management tool for configuration management. It can be used to configure servers, install software packages, deploy applications, and more.

Managing development environments is made easier with Vagrant, a tool for managing virtual machines. It creates a complete machine image that contains everything needed to run a virtual instance of Linux.

Docker is an open-source project for packaging up any application into a lightweight standalone executable. This allows developers to package their app into a small self-contained unit that can then be deployed anywhere.

Jenkins is an automated continuous integration server. It helps teams build software faster by providing a central place to manage builds and test results.

Git is a version control system (VCS). It keeps track of changes made to files and folders within your computer. You can use it to keep track of projects you work on and share them with others.

GitHub is a website where people collaborate on coding projects. Anyone can sign up and create repositories to host code they write.

BitBucket is a cloud-based repository hosting service. It offers unlimited private repositories, free private repos, and enterprise plans.

JIRA is a bug tracking and issue-tracking solution. It has a simple interface and is easy to learn.

PHP, Java, Python, Ruby, C#, etc.

Javascript, CSS, HTML5, etc.

MySQL, PostgreSQL, SQLite, Oracle, MS SQL Server, etc.

The software stack consists of the following:

• Operating System
• Programming Language
• Database Management System
• Application Framework

The acronym stands for Linux, Apache, MySQL, PHP or Perl. These four components make up the most common web development environment.

Semantic HTML is a way of structuring content so that search engines can understand what’s in it.

XHTML is an XML-based language that provides strict guidelines for creating valid markup.

JSON is JavaScript Object Notation. It is a lightweight data interchange format.

Full Stack JavaScript gives you access to all the features of JavaScript. It also makes it easier to develop cross-browser compatible websites.

Responsive Web Design is a technique for designing websites that adapt to different screen sizes. Responsive sites look great on desktops, tablets, smartphones, and even TVs.

Static web pages contain only text and images. They don’t require a database connection. Dynamic web pages connect to databases and retrieve information from them.

Frontend refers to the user interface. Backend refers to the logic behind the scenes. Full stack includes both the frontend and backend.

Single Page Applications (SPA) are web apps that load one page at a time. Multi-Page Applications (MPA) load multiple pages at once.

RESTful APIs are based on HTTP methods like GET, POST, PUT, DELETE, HEAD, OPTIONS, TRACE, CONNECT, etc. SOAP APIs are based on XML messages.

CSS Icons are small graphical elements that represent certain types of objects. You use them as placeholders for other graphics.

Registry libraries provide a central location where developers can store their application settings.

Architectural Patterns are reusable solutions to recurring problems. Design Patterns are specific solutions to particular problems.

Architectural Patterns help solve problems such as how to manage state, how to handle concurrency, how to organize code into modules, and how to separate concerns.

• MVC- Model View Controller
• MVP-Model View Presenter
• MVVM-Model View View Model
• DDD-Domain Driven Development
• TDD- Test Driven Development
• BDD- Behavior Driven Development

We need to have a clear understanding of the problem domain before we start building our architecture. Once we have this knowledge, we can then decide whether our architecture will work well with the problem domain.

Sass is an extension of CSS which provides variables, mixins, nesting, and more.

A Mixin is a function that takes arguments and returns another function. This allows us to reuse functions in various places without having to copy and paste the same code over and over again.

Coercion occurs when a value is coerced into a type. For example, let’s say you want to convert a string to a number. The string “10” would be converted to 10 because it is a valid number. However, the string “1a” would not be converted to 1 because it has characters that cannot be interpreted as numbers.

Prototype Inheritance – When a child object inherits properties from its parent, they are added to the child’s prototype chain.

Prototypal Inheritance – All the properties which are inherited from the parent object are copied to the newly created object when the parent object creates a new instance of itself.

There are four technologies in the MEAN stack – MongoDB, ExpressJS framework, AngularJS, and node.js – used to develop web applications. Developed by MongoDB founder Eliot Horowitz, it is best suited for prototyping, rapid development, and small projects. It is an ideal solution because it is easy to use and requires no server configuration.

MEAN stack is a popular choice among developers because it allows them to build fast and scalable web apps without having to learn complicated frameworks like Ruby on Rails or PHP. This makes it easier to build robust web applications.

Before ES6, variable declarations had to use one of three keywords: var, let, or const. These keywords define the scope of the variable, which determines where it can be used. For example, In JavaScript, global variables such as x can be referenced anywhere, whereas local variables are defined within functions.

With ES6, there are now two additional ways to declare variables: let and const. Let and const both introduce a new concept called block scoping. Block scoping allows us to specify what types of variables can be declared in different places. In particular, let and const are block-scoped; this means that they can only be accessed inside the curly braces ({}) that surround them. This makes them behave differently from regular variables.

Let and const don’t have temporal dead zones, meaning that they can be accessed before being assigned values. However, unlike normal variables, let and const aren’t hoisted to the top of the containing scope. Instead, they must be explicitly declared.

Event Bubbling is the process whereby events propagate up the DOM tree until they reach the document root element (the HTML tag). Once at the document root, the event handler attached to the element receives notification about the event.

In contrast to event bubbling, event capturing is the opposite of event propagation. Event capturing happens when an event propagates down the DOM tree instead of up. An event handler attached to an ancestor element will receive notification about the event. If the event handler does nothing with the event, then the event will bubble back up the DOM tree to the event source.

A base class that contains methods but no data members is called an abstract class. Concrete classes inherit from abstract classes and add data members. An interface defines a set of method signatures that an implementing class must implement.

Defer is a keyword that tells the browser not to execute code right away. Async is a property that indicates whether a function should run asynchronously. Defer executes synchronously, whereas async runs asynchronously.

A left join returns all rows from the first table along with matching rows from the second table. The result has columns for each row in the first table plus columns for matching rows in the second table.

A right join returns all rows from both tables along with matching rows from either table. The result has the same number of columns as the first table.

The first phase is the prepare phase. During this phase, the server prepares the transaction by setting its state to pending and locking out other transactions.

The second phase is the commit phase. During this phase the server commits the transaction by releasing locks on resources and updating the system’s log files.

Horizontal scaling refers to the ability to scale a single application across multiple servers or machines. Horizontal scaling is often used to increase performance.

Vertical scaling refers to the ability of a single machine to handle more requests than it was originally designed to handle. Vertical scaling is often used to reduce costs.

Critical sections are areas of code where access to shared data is restricted. They are typically used to prevent race conditions.

Numeric promotion occurs when one type is promoted to another type. For example, if you have a variable of type int and assign it a value of type long, the compiler automatically converts the value to be of type long. This is called numeric promotion.

SOLID stands for Single Responsibility Principle, Open/Closed Principle, Interface Segregation Principle, and Dependency Inversion Principle. These principles help us write clean software.

A request dispatcher is responsible for dispatching incoming HTTP requests to appropriate handlers. It also handles authentication and authorization.

A servlet filter is a component that intercepts requests before they reach the web container. Filters can perform operations such as logging, security checks, content transformations, etc.

JSP pages are HTML documents that contain embedded Java Server Pages (JSP) tags.