Q: Suppose you're building a REST API using Node.js and Express.
How would you
handle errors globally in your application?
👉 (Please explain your approach or even code structure if you want.)
Answer: "To handle errors globally in a Node.js and Express REST API, I usually
follow a structured approach. First, I create a custom error class that helps me
standardize error messages and status codes across the app. Then, I set up a global
error-handling middleware at the end of my middleware stack, which catches any
error thrown in the application and sends a consistent JSON response to the client.
For async route handlers, instead of writing try-catch everywhere, I use a wrapper
function that automatically catches errors and forwards them to the global handler.
This keeps my code clean and readable.
With this setup, I can manage all types of errors in one place, whether they are
validation errors, database issues, or unexpected server errors. It also makes
debugging easier and improves the overall API reliability."
-----------------------------------------------------------------------------------
-------------------------
Q: Suppose you're working on a product dashboard in React. When the user selects a
product category from a dropdown, the product list should update without refreshing
the page. How would you implement this feature?
👉 Explain your approach including state management, API handling, etc.
Answer:
Sure! To implement dynamic product filtering based on category selection in a React
dashboard, I would follow this approach:
First, I would manage the selected category using React's state, typically with the
useState hook. When the user selects a different category from the dropdown, I
would update that state accordingly.
Second, I would use the useEffect hook to listen for changes to the selected
category. Inside that effect, I would make an API call to fetch the products that
belong to that category.
Third, for the API request, I would either use the Fetch API or Axios to call the
backend with the selected category as a query parameter.
Once the data is received, I would update another piece of state that holds the
product list, and that state would be used to render the products dynamically on
the page.
This way, the product list updates immediately based on the selected category—
without refreshing the page—because React handles the rendering and state updates
internally.
If the app is using a global state manager like Redux or React Query, I could also
manage the selected category and product list there for better scalability,
caching, and performance.
Overall, the key points are using local or global state for selected category and
product list, using useEffect for side-effects like API calls, and ensuring the UI
updates reactively.
-----------------------------------------------------------------------------------
-------------------------
Q: You have an array of integers where every element appears twice except for one
element which appears only once. How do you find that single element efficiently?
👉 Explain your approach and time complexity.
Answer:
To find the single element in an array where every other element appears twice
except one, I would use the XOR operator.
The reason XOR works here is because it has a property where any number XORed with
itself results in zero, and any number XORed with zero results in the number
itself.
So, if we XOR all the elements in the array together, all the pairs will cancel out
each other and the result will be the single element that appears only once.
For example, if the array is [2, 3, 5, 4, 5, 3, 4], XORing all elements will leave
us with 2, because all others appear twice and cancel out.
This approach is very efficient because:
It only requires one pass through the array, so the time complexity is O(n), where
n is the number of elements.
It uses constant extra space, O(1), since no additional data structure is needed.
So overall, this XOR method is an optimal and clean solution for this problem.
-----------------------------------------------------------------------------------
-------------------------
Q: Imagine Cisco Meraki wants to design a scalable dashboard to monitor thousands
of IoT devices in real-time. What key components and technologies would you suggest
to build this system?
👉 Briefly outline your high-level design.
To build a scalable real-time dashboard for monitoring thousands of IoT devices, I
would focus on a few key components and technologies:
Device Communication Layer:
Use MQTT or WebSockets protocols to efficiently handle real-time bi-directional
communication with IoT devices, since these are lightweight and support many
concurrent connections.
Data Ingestion and Processing:
Implement a streaming data pipeline using technologies like Apache Kafka or AWS
Kinesis to collect, buffer, and process the huge volume of device data in real-
time.
Backend API and Services:
Use a microservices architecture with Node.js or Go for scalability. These services
will aggregate data, perform business logic, and expose APIs for the frontend.
Real-Time Updates to Dashboard:
For pushing live updates to the user interface, I’d use WebSocket or libraries like
Socket.io, or use server-sent events, to provide low-latency updates on the
dashboard.
Data Storage:
Use a combination of time-series databases like InfluxDB or TimescaleDB to
efficiently store IoT telemetry data, and a NoSQL database like MongoDB or DynamoDB
for device metadata and configuration.
Frontend:
Build the dashboard with React or Angular for a responsive UI, using state
management (Redux or Context API) and charts libraries like D3.js or Chart.js for
visualizing real-time metrics.
Scalability & Reliability:
Deploy the system on cloud platforms like AWS, Azure, or GCP with auto-scaling
groups, container orchestration using Kubernetes, and load balancers to handle
scaling.
Security:
Implement strong authentication and authorization (OAuth or JWT), encrypt
communication, and monitor for anomalies to secure the IoT ecosystem.
-----------------------------------------------------------------------------------
-------------------------
Q: You are designing an API endpoint to upload user profile pictures. What are the
key considerations you would keep in mind for handling file uploads securely and
efficiently?
Explain your approach.
When designing an API endpoint for uploading user profile pictures, there are
several important considerations to ensure the process is both secure and
efficient:
File Validation:
I would first validate the uploaded file to ensure it’s an image — typically by
checking the file’s MIME type and extension, but more importantly, by inspecting
the actual file headers to avoid malicious files disguised with image extensions.
File Size Limits:
I would enforce a maximum file size limit to prevent users from uploading extremely
large files, which could lead to resource exhaustion or denial of service.
Storage:
Instead of storing images directly on the application server, I’d use a dedicated
storage service like AWS S3 or Azure Blob Storage. This improves scalability and
reduces load on the server.
File Naming & Path:
To avoid filename collisions and potential overwriting, I would generate unique
filenames, often using UUIDs or hashes. Also, it’s important to avoid using user
input directly in file paths.
Security:
I’d ensure the upload endpoint is protected via authentication and authorization so
only authorized users can upload or modify their profile pictures.
Additionally, I would scan uploaded files for malware if possible.
Image Processing:
Often, profile pictures need to be resized or optimized to standard dimensions and
compressed to save bandwidth. This can be done using image processing libraries
either before or after upload.
Serving Images:
When serving profile pictures, it’s best to serve them through a CDN for fast
global delivery.
Error Handling & Feedback:
The API should return clear, appropriate error messages for invalid files, size
violations, or upload failures.
Rate Limiting:
Implementing rate limiting helps prevent abuse of the upload endpoint.
So overall, I would build a secure, scalable upload pipeline with proper
validation, storage offloading, and processing to deliver a smooth and safe user
experience.
-----------------------------------------------------------------------------------
-------------------------
Q: Your React app is slowing down when rendering a large list of items (e.g.,
1000+). What strategies would you use to improve the rendering performance?
Explain briefly.
If my React app slows down while rendering a large list of items, I would use these
strategies to improve performance:
Windowing or Virtualization:
Instead of rendering all 1000+ items at once, I would use libraries like react-
window or react-virtualized. These render only the visible portion of the list on
the screen, significantly reducing the number of DOM nodes.
Memoization:
I would use React.memo to prevent unnecessary re-renders of list items if their
props haven’t changed, and also useCallback or useMemo hooks to memoize functions
and expensive calculations.
Key Prop Optimization:
Ensure that each list item has a stable and unique key prop to help React
efficiently update the DOM.
Avoid Inline Functions and Objects:
Avoid passing inline functions or objects as props in the list, as it can cause re-
renders. Instead, define them outside or memoize them.
Pagination or Lazy Loading:
If possible, implement pagination or lazy loading so that the app fetches and
renders data in chunks rather than all at once.
Use Pure Components:
When applicable, use pure components or shouldComponentUpdate to control rendering
behavior.
These approaches combined help keep the UI smooth and responsive even with large
data sets.
-----------------------------------------------------------------------------------
-------------------------
Q: Suppose you have a relational database for an e-commerce app. How would you
design tables to handle users, products, orders, and order items?
Briefly outline key tables and their relationships.
For an e-commerce app with a relational database, I’d design these key tables:
Users Table:
Stores user information like user_id (primary key), name, email, password hash, and
contact details.
Products Table:
Contains product details such as product_id (primary key), name, description,
price, stock quantity, and category.
Orders Table:
Represents customer orders, with order_id (primary key), user_id (foreign key
referencing Users), order date, status, and total amount.
Order Items Table:
This is a join table that links orders to products. It has order_item_id (primary
key), order_id (foreign key referencing Orders), product_id (foreign key
referencing Products), quantity, and price at the time of order.
Relationships:
One User can have many Orders (one-to-many).
Each Order can have many Order Items (one-to-many).
Each Order Item references one Product (many-to-one).
This normalized design ensures data consistency and supports typical e-commerce
workflows like order tracking and inventory management.
-----------------------------------------------------------------------------------
-------------------------
Q: How would you deploy a full stack app (React frontend + Node.js backend) for
production? Mention key steps and best practices.
Your turn!
To deploy a full stack app with a React frontend and a Node.js backend in
production, I’d follow these key steps and best practices:
Build the Frontend:
First, I’d run the React build command to create an optimized, production-ready
static bundle.
Prepare the Backend:
Make sure the Node.js backend is production-ready by handling environment variables
securely, setting up proper logging, and enabling error handling.
Choose a Hosting Platform:
For the backend, I could use services like AWS EC2, DigitalOcean, Heroku, or
container platforms like Docker with Kubernetes for scalability. For the frontend,
I’d use a CDN-backed static hosting service like Netlify, Vercel, or AWS S3 +
CloudFront.
Configure a Reverse Proxy:
Use Nginx or a similar reverse proxy to serve the frontend and proxy API requests
to the backend, ensuring smooth routing and better security.
Environment Variables & Secrets:
Manage sensitive data like API keys or database credentials via environment
variables or secret management tools, never hardcoded in the code.
Use HTTPS:
Secure the app with SSL certificates using services like Let’s Encrypt to enable
HTTPS.
Set Up a Database:
Deploy the production database with backups and monitoring, ensuring it’s secure
and highly available.
Implement CI/CD:
Automate the build, test, and deployment processes using CI/CD pipelines (GitHub
Actions, Jenkins, CircleCI) to reduce manual errors.
Monitoring & Logging:
Set up monitoring tools like Prometheus, Grafana, or third-party services (New
Relic, Datadog) to track app performance and errors.
Scaling:
Configure auto-scaling based on traffic, use load balancers, and optimize caching
to handle increased load.
Following these steps ensures the app is performant, secure, and maintainable in
production.
-----------------------------------------------------------------------------------
-------------------------
