| | | 20,000+ Fresh Resumes Monthly | |
|
|
| |
Click here or scroll down to respond to this candidate Candidate's Name
EMAIL AVAILABLE || PHONE NUMBER AVAILABLE || Linkedin
Summary
I am an accomplished Senior MERN Stack Developer with over 9+ years of experience building complex user interfaces for large-
scale applications. I have worked on projects for major corporations including Cigna, DXC Technology, and Sonic Healthcare. My
expertise spans HTML5, CSS3, JavaScript, TypeScript, Angular, React, Redux, Vue.js, Node.js, Express, MongoDB, and other
related technologies. My expertise also spans in Figma, Sketch, Invasion, Adobe Suit, Wire Framing and Other designing Tools. I
build high-performance front-ends that connect securely to back-end systems. I have a Bachelors in Computer Science and am
adept at Agile methodologies, responsive design, RESTful services, Git, and modern web frameworks. I am an analytical problem-
solver able to deliver complex front-end systems from design to deployment. My attention to quality and testing ensures robust
and scalable applications. With my strong technical skills and experience with large development teams, I can provide valuable
front-end engineering leadership on critical user-facing initiatives.
Technical Skills
Web Technologies: JavaScript, ES6, AJAX, jQuery, WordPress, Typescript, JSON, Bootstrap, AngularJS, React.js,
BackboneJS, Express.JS, D3.JS, Node.js, Next.JS, Typescript, Redux, HTML5, CSS3
UI/UX Designer Tools: Figma, Adobe XD, IN Vision, Adobe Suit, Wireframing, Prototyping.
Databases: MySQL Server, Mongo DB, PostgreSQL
Version Controls: GitHub, Git
Cloud Platform: AWS (S3, Lambda, CodePipeline), Microsoft Azure
Testing Tools and Packages: NPM, Jasmine, Mocha, Cucumber, Chai, Cypress, Jest, Selenium, Jira
DevOps: Kubernetes, Docker
CI/CD Tools: Jenkins, CircleCI, GitLab, OAuth
Methodologies: Agil, Scrum.
Others: RabbitMQ, KAFKA, Elasticsearch, RestfulAPI`s, MVC Architecture, HL7, SOAP API, Restful API
Work Experience
Cigna || Senior MERN Stack Developer|| Mar 2021 - Present
Responsibilities:
Throughout my career, I've had the privilege of leading and collaborating with talented teams across various domains.
As a front-end team lead, I've not only developed work plans but also reviewed and harmonized timelines across
different teams. This collaborative approach has helped us meet project deadlines consistently, fostering a sense of
unity and shared success.
In my role, I've always believed in the power of cross-functional collaboration. I've actively engaged with various
teams to collect and analyze requirements, ensuring that everyone's voice is heard. This inclusive approach has often
led to innovative solutions that truly reflect the collective wisdom of our diverse teams.
Working closely with clients has been a rewarding experience. I've proactively gathered their feedback within Figma,
leveraging its collaborative features to facilitate real-time discussions. It's gratifying to see how this approach allows
us to make prompt adjustments, ensuring that the final product aligns seamlessly with the client's vision.
I'm particularly passionate about enhancing user experiences. In Figma, I've integrated dynamic transitions among
screens and components, presenting animations and micro-interactions that emulate the eventual user experience.
As a developer, I've spearheaded initiatives to optimize React.js applications. By implementing memorization
techniques and harnessing React's virtual DOM, we've achieved substantial performance improvements.
Transitioning between different technologies can be challenging, but it's a challenge I relish. I've executed thorough
code refactoring to harmonize Angular code patterns with React's component-based architecture. Not only does this
enhance code readability and maintainability, but it also fosters a sense of unity in our codebase, making it easier for
team members to work across different parts of the application.
Throughout my career, I've been part of creating different web applications using a variety of technologies: HTML,
CSS, Node.js, React.js, and Redux. Beyond just development, I've taken responsibility for maintaining these
applications and addressing bug fixes.
In my work with Bootstrap, I've gone beyond just using it out of the box. I've optimized its grid system to meet specific
project requirements, ensuring efficient and consistent layout structures.
React Hooks have been a game-changer in my work. I've utilized them extensively for stateful logic and side-effects,
optimizing functional components for improved readability and maintainability. It's gratifying to see codebases that
are not only functional but also easy to understand and extend.
API design is another area where I've made significant contributions. I've designed and implemented strategies for
versioning RESTful APIs in Node.js applications, ensuring backward compatibility and facilitating smooth transitions for
clients. This forward-thinking approach has saved our clients from potential disruptions during updates.
Security is always important in my work. I've incorporated JSON Web Token (JWT) authentication middleware into
Node.js applications to ensure secure and scalable user authentication. It's reassuring to know that our users' data is
protected by robust and industry-standard security measures.
In the realm of distributed systems, I've implemented event-driven architectures utilizing messaging systems like
RabbitMQ or Kafka. This approach improves decoupling and scalability, allowing our systems to grow and evolve more
flexibly.
Testing is another passion of mine. I've executed comprehensive testing strategies, including unit testing, integration
testing, and end-to-end testing, leveraging frameworks like Jest or Mocha. The satisfaction of seeing all tests pass,
knowing our code is robust, is unparalleled.
In today's cloud-centric world, I've embraced containerization. I've Dockerized Node.js applications, ensuring
consistent and reproducible deployments across various environments. This not only simplifies deployment but also
significantly reduces "it works on my machine" issues.
I've overseen the management and optimization of PostgreSQL databases, always prioritizing data integrity, security,
and performance. There's a certain satisfaction in seeing a database that not only stores data but does so efficiently
and securely.
I've been an early adopter of GraphQL, introducing and implementing it for frontend-backend communication. This
has optimized data fetching and provided a flexible API for frontend developers. The joy of seeing developers able to
request exactly the data they need, no more and no less, is immense.
Authentication is a critical aspect of any application. I am incorporating OAuth flows, such as Authorization Code and
Implicit, to accommodate diverse authentication scenarios. This flexibility ensures that our applications can adapt to
various authentication requirements without compromising security.
Transitioning between different testing frameworks can be challenging, but it's a challenge I enjoy. I've transitioned
from Angular testing tools to React testing libraries like Jest and React Testing Library. Revising unit tests, integration
tests, and end-to-end tests for React components not only ensures our tests are effective but also deepens my
understanding of both frameworks.
Utilized pre-request scripts in Postman to dynamically modify requests, set headers, or manipulate data before sending
API requests. This allowed for flexible and customized interactions with APIs during testing and development.
As my career has progressed, I've had the opportunity to architect complex UI components by applying advanced
React.js patterns and concepts. This experience has taught me that even in the world of front-end development,
architectural decisions can have a profound impact on maintainability and performance.
I've always been interested in cross-cutting concerns in software development. I've integrated aspect-oriented
programming principles into the MVC architecture, improving how we handle concerns such as logging, security, and
caching. This approach has led to cleaner, more modular code that's easier to maintain and extend.
In the area of authentication, I've been using OAuth for Single Sign-On (SSO) solutions. Enabling users to access
multiple applications with a unified authentication not only enhances security but also significantly improves the user
experience. It's rewarding to see users appreciate this convenience.
Collaboration extends beyond just coding. I've teamed up with database administrators to optimize intricate queries,
resulting in a 17% reduction in query execution times. We've also implemented indexing strategies to enhance overall
performance. This collaboration has taught me the value of cross-disciplinary teamwork.
In my DevOps role, I've automated complex workflows in CI/CD pipelines, incorporating parallel testing, canary
deployments, and automated rollback strategies. This ensures robust and reliable release processes, giving our team
confidence in each deployment.
Working with microservices has been a significant part of my career. I've orchestrated a microservices architecture
with Kubernetes, utilizing Helm charts and Kubernetes Operators to handle complex applications. This has resulted in
enhanced scalability and fault tolerance, making our systems more resilient.
Docker has been a game-changer in my work. I've executed Docker configurations for multi-environment support,
adeptly managing development, testing, and production environments through Docker Compose. This has
significantly streamlined our development process, reducing environment-related issues.
Testing is integral to my DevOps approach. I integrate testing into CI/CD pipelines using tools like Jenkins, Travis CI, or
CircleCI. This ensures that every code change is thoroughly tested before it reaches production.
In projects using AWS services, I've implemented and managed CI/CD pipelines using AWS Code-Pipeline, Code-Build,
and Code-Deploy. This tight integration with AWS services has led to more efficient and seamless deployment
processes.
I've also ventured into building robust and scalable APIs with TypeScript using the Express.js framework. This
combination enhances code maintainability, catching potential errors early in the development process.
For Next.js applications, I've taken charge of establishing CI/CD pipelines for automated testing, code quality checks,
and streamlined deployment. This fosters an efficient and reliable development workflow, allowing our team to
iterate quickly and confidently.
Even with older technologies like jQuery, I've found ways to enhance performance by minimizing manipulations of the
Document Object Model (DOM) and utilizing effective selectors. This experience has taught me that optimization is
possible in any technology stack.
Lastly, I've been designing and implementing serverless architectures leveraging AWS Lambda, API Gateway, and
other services. This approach has allowed us to build highly scalable and cost-effective solutions, focusing on business
logic without the overhead of server management.
Throughout my career, I've been driven by a passion for continuous learning, collaboration, and leveraging technology
to solve complex problems. Each project and technology have taught me something new, contributing to my deep and
broad understanding of software engineering and DevOps practices.
DXC Technology || Front End Developer || Jun 2018 Feb 2021
Responsibilities:
Using Figma to create clear and engaging visual documentation, design specs, and interactive prototypes that made it easy
for everyone on the team, from developers to stakeholders, to understand the project's progress and goals.
One of the project I worked on e-commerce platforms using the MERN stack (MongoDB for the database, Express.js for
the backend, React for the frontend, and Node.js for the runtime environment). This allowed me to create online stores
that could handle a wide range of products and meet the unique needs of different customers.
Collaborating with remote design teams using Figma's real-time collaboration features, which made working together
seamless and efficient. I also used Figma's Auto Layout to create designs that automatically adapted to different screen
sizes, ensuring a great user experience across devices.
When it came to upgrading AngularJS applications to newer versions of Angular, I developed and carried out migration
strategies that made the transition smooth and painless, without breaking any of the existing functionality.
To catch any visual bugs or unexpected changes in the user interface, I implemented snapshot testing for UI components.
This involved capturing visual snapshots of the UI and comparing them over time to detect any issues.
Also, involved in implementing Express.js middleware to handle Cross-Origin Resource Sharing (CORS), which allowed the
AngularJS frontend and Node.js backend to communicate securely and without any issues.
To make the API endpoints more reliable, I implemented error handling middleware in Express.js. This middleware caught
and gracefully handled any exceptions or errors that occurred, preventing the API from crashing or returning incorrect
responses.
I designed and implemented caching strategies for RESTful APIs to improve their performance. This involved using
techniques like ETag headers and caching directives to reduce the number of requests made to the server and speed up
response times.
Incorporating Apollo Client and Server into Angular applications to streamline data fetching and state management using
GraphQL. This made the application more efficient and reduced the amount of boilerplate code needed.
In RabbitMQ, I implemented exchange-to-exchange bindings to enable more complex routing scenarios and make the
messaging system more flexible and powerful.
When working with AngularJS, I seamlessly integrated external libraries and made sure they were fully compatible and
optimized for use within the framework.
Ensuring the quality and reliability of the applications I built, I designed and executed thorough functional, regression, and
performance tests using tools like Selenium and Cypress.
Stayed up-to-date with the latest JavaScript features and adopted ES6+ syntax like arrow functions, destructuring, and
async/await to make my code more readable and maintainable.
When building server-side applications, I used TypeScript to combine the benefits of static typing with the flexibility of
JavaScript. This helped catch potential bugs and improve the overall quality of the code.
To retrieve data from Elasticsearch efficiently, I leveraged its Query DSL (Domain Specific Language) to construct complex
and tailored queries that could precisely fetch the needed information based on various criteria.
I conducted advanced memory management in JavaScript applications, identifying and fixing memory leaks to optimize
performance and prevent crashes or slowdowns.
For comprehensive API testing, I utilized Postman to validate endpoints, verify request/response data, and automate test
scenarios, ensuring the APIs were robust and functioned as expected.
To create a unique and cohesive visual style across the application, I customized Bootstrap styles using SASS. This involved
adjusting variables and mixins to match the desired design language.
I integrated Application Performance Monitoring (APM) tools like New Relic and Datadog into JavaScript applications to
gain real-time insights into their performance, identify bottlenecks, and optimize accordingly.
Using Express.js middleware, I implemented security measures like CORS and CSRF protection for frontend API calls,
safeguarding the application from common web vulnerabilities.
In PostgreSQL databases, I implemented real-time data replication strategies to ensure high availability and minimize
downtime during migrations. This kept the data consistent and accessible even during maintenance or upgrades.
To optimize page load times and resource usage, I utilized the Intersection Observer API to lazy-load images and content.
This technique loaded resources only when they were needed, improving the overall performance of the application.
leveraged TypeScript interfaces to enforce strict data validation and maintain consistency in the structure of API request
and response payloads, preventing data-related issues and ensuring reliable communication between the frontend and
backend.
When executing complex database migrations, I employed strategies like database sharding and blue-green deployments
to achieve zero downtime. This allowed for smooth transitions without interrupting the availability of the services.
To fetch data asynchronously without reloading the entire page, I implemented AJAX requests using jQuery. This provided
a seamless user experience and improved the responsiveness of the application.
In my testing workflows, I paired the Mocha testing framework with the Chai assertion library. This combination allowed
for expressive and readable assertions, making it easier to create comprehensive test cases that covered various scenarios.
Managing complex state in user interfaces, I utilized state management libraries like Redux. This made the application
more scalable and maintainable by providing a centralized store for managing the application's state.
When working on Angular projects, I used TypeScript as the primary language to take advantage of its static typing
capabilities and rich tooling support. This helped catch type-related issues early in the development process and improved
the overall quality and maintainability of the codebase.
In situations where I needed to convert Angular components to React, I carefully addressed the differences in lifecycle
methods, state management, and rendering approaches. By understanding and reconciling these differences, I ensured a
smooth integration of the converted components into the React ecosystem.
I actively collaborated with DevOps teams to streamline the development and deployment processes, leveraging
automation and best practices to optimize the workflow. Additionally, I regularly participated in AWS communities,
forums, and events to stay up-to-date with the latest trends, share knowledge, and continuously expand my skills in cloud
technologies.
Sonic Healthcare || Front End Developer|| July 2015 May 2018
Responsibilities:
Prototyped, built, deployed, and maintained several projects from scratch using React, ensuring the products were stable
and maintainable throughout the development lifecycle.
Conducted usability testing in Figma by creating user scenarios and tasks. Observed and analyzed user interactions to
identify areas for improvement in the wireframes and overall design, enhancing the usability of the designs.
Actively participated in daily stand-up meetings, openly discussing progress, challenges, and future plans with the team.
Fostered effective communication and collaboration among team members.
Developed responsive user interfaces using ReactJS that seamlessly adapted to various screen sizes, from mobile devices to
large screens, ensuring a consistent and optimal user experience across different platforms.
Demonstrated a strong command of React hooks, leveraging their capabilities to efficiently manage state and lifecycle
methods within functional components. Exhibited proficiency in creating wireframes and designing interfaces using Figma.
Embraced Agile project management methodologies, such as Scrum or Kanban, to facilitate iterative development,
continuous improvement, and adaptability. These frameworks provided a structured approach to delivering high-quality
software incrementally.
Designed and implemented responsive and mobile-friendly web designs using HTML5 and CSS3, ensuring that the user
interface remained visually appealing and functional across different devices and screen sizes.
Collaborated closely with UX/UI designers to implement visually appealing and user-friendly interfaces, translating design
mockups into functional and interactive web pages.
Performing Configurization and customized Jira workflows to align with the team's specific needs, streamlining the
development process. Ensured a smooth and efficient progression of tasks from creation to completion, enhancing
productivity and transparency.
Set up monitoring tools like Kibana to proactively track the health and performance of Elasticsearch clusters. Leveraged
logging and monitoring capabilities to quickly identify and resolve any issues, ensuring the stability and reliability of the
system.
Developed and maintained frontend code using popular JavaScript frameworks such as React and Angular. Leveraged the
power of these frameworks to build dynamic and interactive user interfaces.
I've always been excited by new technologies that blur traditional boundaries. Integrating CSS-in-JS solutions like
styled-components or Emotion into projects offers a seamless approach to managing styles within JavaScript
components.
Dynamically adjusted HTML element attributes using jQuery functions, enabling real-time updates and enhancing the
interactivity of web pages.
Utilized TypeScript into the project to improve code quality and maintainability. TypeScript's static typing features helped
catch potential errors early in the development process and provided better tooling support.
Collaborated with backend developers to integrate Angular applications with RESTful APIs, ensuring smooth communication
and data exchange between the frontend and backend components.
Adhered HL7 standards in healthcare-related projects to ensure seamless interoperability of healthcare data. Maintaining
compliance with industry standards to facilitate the accurate and secure exchange of information between systems.
Utilizing Mocha test suites to organize and structure tests effectively. Leveraging features like hooks for setup and
teardown operations, making the test code more modular and maintainable.
Also analyzed and optimized SQL queries to improve their execution efficiency. Considered factors such as indexing, join
types, and subqueries to fine-tune the queries and minimize response times and resource consumption.
Used TypeScript's type inference capabilities to allow the compiler to automatically deduce types when they are not
explicitly specified.
Following the Test-Driven Development (TDD) approach, which involves writing a failing test first (Red), then making it pass
(Green), and finally refactoring the code while ensuring the tests remain successful.
Implementing connection pooling techniques to efficiently manage database connections and prevent connection-related
issues. Maintaining a pool of reusable connections to optimize resource utilization and improve application performance.
Staying updated on the latest trends and best practices in JavaScript, HTML, and CSS development. Continuously learning
and adapting to new technologies and approaches to ensure skills remain relevant and up-to-date.
Education
Bachelor of Technology in Computer Science
- NIIT University (2011 2015)
|
