We provide IT Staff Augmentation Services!

Java/angular/ Mongodb Full-stack Developer Resume


  • Extensive experience as a Java/Node.js full stack Web Developer, creating Single Page Web applications using Angular 2+, Node.js, and React.js with backend using Spring Boot/Express.js.
  • Proficient in developing Single Page Applications (SPA) using Angular 2+ and React.js.
  • Developed SPA by using Angular related technologies such as TypeScript, Angular Components, Directives, Pipes, Services, HTTP Client, Observables/Promise, Reactive/Template driven forms, Two - way data binding, Life Cycle Methods, Routing, and Routing Guards within multiple components.
  • Developed SPA by using React related technologies such as JavaScript ES6, Redux, CSS Module, Dynamic Styling, Axios, React Components, Props, States, Two-way data binding, Promise, Conditional Expression, Life Cycle Methods, High Order Component, Props Validation, Routing, and Router Guard within multiple components.
  • Extensive experience in using front-end technologies like HTML5, CSS3, Bootstrap, JavaScript, jQuery, and AJAX for building dynamic, user-friendly, and high-performance web applications.
  • Applied responsive web design to fit all users and devices from desktop to tablet and mobile phone by using Grid Systems and Media queries.
  • Extensive experience in Backend Server-Side Programming using J2EE technologies like Java Core, Spring Core, Spring MVC, Spring Boot, Spring AOP, XML, Hibernate, Spring Data MongoDB/JPA, Spring JDBC, and Node.js with Express.js.
  • Proficient in developing RESTful API using J2EE Technologies/Express and testing APIs using Postman, Swagger, cURL.
  • Expertise in database system like SQL Server, Oracle, MySQL, PostgreSQL and NoSQL database MongoDB. Proficient in performing CRUD and Other SQL operations using Relational Database.
  • Expertise in Unit Testing by using Karma, Jasmine, and Jest in frontend, while JUnit and Mockito in Java backend, Mocha and Chai in Node.js Backend.
  • Proficient in debugging and troubleshooting existing code using JIRA/Azure DevOps, Developer tools, and GIT as Version Control System.
  • Involved in all stages of Software Development Life Cycle (SDLC) as well as working in AGILE Methodologies based development environment, participating in spring/iterations, and SCRUM meetings.


Languages: JavaScript/TypeScript/Node.js, Java, C++, shell scripts, SQL

Databases: MySQL, PostgreSQL, MongoDB, SQL Server, Oracle

Web Technologies: Angular 2+/NgRx/RxJS, Angular Material, PrimeNG, HTML, CSS/SASS, Bootstrap, jQuery, AJAX, React/Redux, React Bootstrap

Java Backend: Spring Boot/Microservice, Spring AOP, Spring Core, Hibernate, Spring Data JPA/MongoDB, Spring JDBC, Maven, XML, Joda-beans, Jackson. Spring MVC, J2EE, Servlet, JSP

Node.js Backend: Node.js, Express.js, sequelize, pg/pg-promise, moogoose

Tools: and IDEs: Eclipse/ IntelliJ IDEA, Visual Studio Code/WebStorm, Azure Data Studio/SQL Server Management Studio, Oracle SQL Developer, MySQL Workbench, pgAdmin.

Version Control: GIT, GitHub, Bitbucket, Azure Repos

Debugging/Testing Tools: Jasmine, Karma, Jest, Mocha, Chai, JUnit, Mockito, Postman, Swagger, cURL, cypress

Operating System: MAC OS X, Ubuntu/Linux Mint, Windows


Confidential Cincinnati, OH

Java/Angular/ MongoDB Full-Stack Developer


  • Worked under “Fiji” team to develop the “Prism” KPM module which exists as a part of the whole Nx Monorepo application. The tech stack is Angular 9, Spring Boot, Spring AOP, Spring Data MongoDB, Docker, and MongoDB.
  • Designed multiple UI components such as kpm plan creation, upc validation, channel selection, audience size, side bar filter and dashboard table.
  • Developed the UI interface based on Figma blueprints by UX designers, with private library called “meridian” which is internally designed with PrimeNG by meridian team.
  • View-Form-SchemaForm Design pattern based on Reactive Forms. Applied @Input @Output and service to realize parent-child-grandchild component communications.
  • Created several FormControls with FormBuilder.group() method, used setValidators() from AbstractControl class to add validators for each formControl, and Updated FormGroup values with patchValue()/ setValue() method.
  • Interacted with backend planning CRUD service by using HttpClient. Saved the plan data in our self-defined store (designed with a Map). Retrieve some other related data from other teams’ NgRx store with selectors, which is designed with action, effect and reducer.
  • Designed a workflow service for each page routing switch, like submit, back. Jumping page with router navigateByUrl() or window.location.href.
  • Applied RxJS library like, subscribe multiple Observables with combineLatest() method, change Observable with pipe(), map() and filter().
  • Wrote Custom Pipes by implementing PipeTransform and overriding transform() method with @Pipe Dependency injection. Also Custom Directive with @Directive.
  • Applied conditional rendering with *ngif. For example, dynamically loading schema form in difference channel selection scenarios (by checking if this FormControl exists).
  • Applied JavaScript ES6 features like Template literals for routing url concatenation.
  • Wrote frontend unit test cases with Karma and Jasmine with multiple methods like describe(), beforeEach(), it(), expect(). Call fake backend service with SpyOn() and callFake() methods. Created fake service with TestBed.inject() method.
  • Applied Spring Boot/Microservices in backend, with Gateway microservice to service microservice design pattern.
  • Wrote APIs with @GetMapping, @PostMapping, @PutMapping and @DeleteMapping. Handle url path parameters with @PathVariable and @ RequestParam.
  • Designed custom annotations with @interface, @Retention and @Target. Adding extra methods without changing the original file by using Spring AOP, example like @Around to one of the custom annotation.
  • Used ResponseEntity to Manipulate the HTTP Response. MongoTemplate to realize CRUD operations. Run docker-compose up to create database images.
  • Wrote unit test cases with JUnit @Test @Before, Mockito @Mock @InjectMocks.
  • Applied JSON Schema to mock data in backend with @Value to inject to apis.
  • JIRA as the product management tool for task assignments and process tracing in Agile environment. Daily Standups and Sprint planning via Microsoft Teams. Git and Enterprise Github for version control and code merge.

Environment: Java 11, Spring Boot, Angular 9/PrimeNG, Git, MongoDB, Mac OS, JIRA.

Confidential, Columbus, OH

Node.js/Angular/PostgreSQL Full-Stack Developer


  • Develop a single page web application (SPA) based on the RESTful API using Angular 7, Node.js, Express.js, pg-promise/sequelize, and PostgreSQL.
  • Config Manifest xml to let Excel workbook talk to Angular application using Office.js
  • Mostly develop Angular 7 Components and Service. Write Controller binding functions.
  • Build react forms with a wide range usage of FormArray and FormGroup especially for a list of same attributes. Angular 7 Material for most of Page Elements.
  • Parent-Child-Grandchild Component Communication with @input, @output/emit() @ViewChild, local reference, and service.
  • Angular CLI to build the project and generate component use ng g c. Create service/DI (with @injectable) by using ng g s and inject into component constructor for usage.
  • Frequently use Observable and RxJS library for Reactive Programming. Mimic redux State Mechanism by creating a state service with a global Observable, when the Database refresh, state will automatically be refreshed by Observable subscribing in ngOnInit(). Use RxJS pluck() to retrieve part of state attributes and do some operations with map().
  • Build Angular model for Observable type to receive JSON data. Applied HttpClient to call RESTful APIs and subscribe the observable to get the JSON model data. Build HttpParams, HttpHeader and added as HttpClient option parameters.
  • Utilized storybook to for Angular to simulate pages, requirements and visual state via several action() methods before developing the exact the page.
  • Karma and jasmine for unit test via describe() and may it() methods. Config test.ts for single component test. Ng test command to run the component test cases.
  • Applied Express with Microservice Architecture to build the backend project structure, Data, Controller, and Routes.
  • Widely use JavaScript Data Structure (Array, String, Promise, Map, Math, Stack). Applied JavaScript ES6 features, for example, let and const, arrow function etc.
  • Handle Promise or Async/Await (handled exceptions with multiple try catch blocks) for Asynchronous Operations.
  • In Controller layer, utilize Express Request by calling req.body for requestBody JSON data in POST protocol and pass to the data layer. Conditionally called req.params, req.query for path parameters and query parameters in different apis. Applied Response via res.status.send() to give a http response and required data needed for frontend.
  • In Data layer, apply pg-promise/sequelize, call raw SQL with String compensation (sql with req.query parameters) via pg promise any(), none() and sequelize query() method.
  • Write some PostgreSQL Store procedures/Functions to provide data to return a promise result set to backend data layer. Use Promise.all() to extract the result set data.
  • Automatically called the RESTful api “/api/auth/login” with client id and client secret to request a Ping Federate Token for All RESTful API Authentication when the angular application start in ngOnInit(), Applied Crypto for hashing to encrypt the token before saving to localStorage and decrypt to parse as a Http Authentication header part in ui.
  • Test Restful APIs in Postman during DEV period while apply Swagger OpenAPI 3.0 by config each features yaml file during QA period.
  • Applied winston and winston-daily-rotate-file package for Logger.
  • Utilize Process.env to dynamically load setting environment variable into a json file (settings.template.json) from DockerFile for DEV and QA environment both.
  • Mocha and Chai for backend unit test. cURL for restful API unit test in shell script.
  • Config some settings azure-pipelines.yaml file and run Azure Pipeline to deploy local code to DEV environment for Continuous Integration/Continuous Delivery. Create pull requests with some reviewers’ approval before deploying to qa.
  • Docker, Kubernetes, Azure Kubernetes Service (AKS) for deployment in Azure. Config some of url/server name, value settings in custom environment variables for kubernetes in value-dev.yaml, value-qa.yaml file.
  • Azure DevOps as the product management tool for task assignments and process tracing in Agile environment. Daily Standups for process reports and Sprint planning. Git and Azure Repos for version control and code merge.

Environment: Node.js, Express, HTML, SASS, Angular 7/Material, Git, PostgreSQL, Windows Excel, Office.js. Azure DevOps.

Confidential, New York, NY

Java/Angular/ MySQL Full-Stack Developer


  • Contributed to a team in developing a single page web application (SPA) based on the RESTful API using Angular 6, Spring Boot, Spring JDBC/Hibernate/Spring Data JPA, and SQL Server.
  • Designed multiple components such as product dashboard, product filter, product list, product details, and user login/register with JWT authentication and authorization.
  • Used Angular Routing to navigate between different components. Involved Angular Route Guard for the Authentication and Authorization by passing logged users’ Json Web Token (JWT) into Browser localStorage.
  • Used Template Form to validate the user’s input in Login and Register Components, while React From for handling complex scenarios.
  • Utilized Directives in the application. For example, structure directives like *NgFor to dynamically exhibit multiple data entries, attribute directives like NgClass to add and remove CSS classes on an HTML element, and customer directives which can be reused.
  • Wrote Customized Pipes based on business Logics by implementing PipeTransform interface.
  • Used @input, @output, @Viewchild, local reference, and service for Component Communication.
  • Applied Dependency Injection and service with @Injectable decorator.
  • Used Http Client Module to send http request including GET, POST, PUT, and DELETE to call Corresponding Backend RESTful APIs with @RequestMapping Annotations in Controller Packages.
  • Used Snapshots to call the router initial data and Observables (RxJS library) to handle asynchronous data calls coming from backend REST APIs.
  • Designed customized Interceptors by implementing HttpInterceptor interface to add authorization header with Json Web Token and handle the global error.
  • Broadly Applied Spring Boot with Microservice Architecture to build the backend project structure: Model, DAO, Service, and Controller.
  • Applied Maven as Package Management tool to maintain the version of the dependencies.
  • Added joda-beans-maven-plugin to pom.xml and executed mvn joda-beans:generate to automatically generate the Joda Beans in model layer.
  • Utilized Jackson Annotation/Gson to mapping JSON data with Java Bean Model fields.
  • Decided to use Spring JDBC (JdbcTemplate to execute pure sql, SimpleJdbcCall to call store procedure/Function, etc) OR to use ORM framework with Hibernate (Criteria Queries) / Spring Data JPA (JpaRepository, CrudRepository, etc) for complex mappings in DAO layer. Log4j for Logger.
  • @RestController,@GetMapping, @PostMapping, @PutMapping, @DeleteMapping, @RequestBody, @RequestParams, @PathVariable in RESTful APIs Controller layer.
  • Actively to use Dependency Injection with Spring Annotations @Autowire, @Service, @Resource OR specific library like Google Guice @Inject etc.
  • Test RESTful APIs in Swagger UI by using @ApiOperation and @ ApiImplicitParams (query paramters). Alternatively, Postman and curl commands are also useful solutions.
  • Utilized Postman, cURL, and Mockmvc to test REST controller, while JUnit assertEquals() and Mockito when() to test service layer.
  • Wrote Store Procedures and Functions mostly to interact with MySQL.
  • Broadly used Atlassian products, like JIRA as the product management tool for task process tracing in Sprint planning Agile Environment, Confluence for documentation, CI/CD pipelines deploying code to DEV.
  • Used Git and Bitbucket for version control and troubleshot with merge conflicts and joined the SCRUM meeting for report. Docker, Kubernetes for deploying to AWS Cloud.

Environment: JavaScript, Typescript, HTML, CSS, Bootstrap, Angular 6, Git, Java Core, Spring Boot, Hibernate 5, MySQL, JIRA, Confluence, Windows, and MAC OS X.

Confidential, Golden Valley, MN

Java/React/SQL Server Full-Stack Developer


  • Developed a single page web application (SPA) based on the RESTful API using React and Redux, Spring MVC, Hibernate, and SQL Server.
  • Responsible for creating and maintaining reusable stateful and stateless components.
  • Utilized React Life Cycle Hooks Methods such as ComponentWillMount(), ComponentDidMount(), ComponentDidUpdate(), and render() in some components.
  • Called setState() method to update the stateful component global state and then re-render DOM. Used React Props for Parent and Child Component Communication.
  • Used Axios to perform CRUD operations by sending http requests to call backend RESTful APIs. Utilized Axios Interceptors to handle global errors and add authentication header.
  • Used Redux (Action, Middleware, Reducer, Store) for managing Application Global State and handling user authentication.
  • Dispatched multiple actions in Action layer and tackled actions in Reducer layer based on action types.
  • Applied react-router, react-router-dom, and react-router-native libraries to handle Routing among different components. Applied conditional rendering in Router Guard for user Authentication and Authorization by checking Json Web Token (JWT) in browser localStorage.
  • Performed form validations by adding input fields and validation labels inside element and populating onSubmit function to globally validate user input.
  • Designed middleware by using redux-thunk to tackle asynchronous code.
  • Applied JavaScript ES6 features like const, let, arrow function, template literals etc.
  • Involved CSS module for every component and utilized Radium and High Order Component (HOC) for CSS styling.
  • Used @trendmicro/react-sidenav library for Navigation bar.
  • Used SpringMVC architecture to build the backend project structure layers: Domain, DAO, Service, Controller, Exception, and Utils. Configured web.xml by adding spring MVC DispatchServlet. Configured Hibernate setting parameters for Database Connection in /src/main/resource/application.properties file.
  • Utilized Object-Oriented Programming (OOP) design patterns such as inheritance, polymorphism, Encapsulation interface, abstraction, overloading, and overriding. Applied Collections such as Set, HashMap and List to store data and passed through layers.
  • Used Maven to handle and update dependencies, run maven build, maven clean install commands to start, and refresh the backend applications.
  • Designed Object relational Mappings (ORM) patterns (Mapping each POJO class to database table) by creating a corresponding Hibernate Mapping file(hbm.xml) and used Java-based Annotations inside POJO classes such as @Entity, @Table, @Column, @Id, @GeneratedValue and so on.
  • Extensively applied other Hibernate and database management technologies like Sessions, transactions, criteria queries, Hibernate Query Language (HQL), Native SQL, Cache, Batch Processing, and Interceptors, to interact with the database.
  • Used @CrossOrigin Annotation in Controller Layer to fix front-end and back-end different ports data communications problems.
  • Developed some Spring customized Dependency Injections based on business logics.
  • Used Azure Data Studio for SQL Server Database graphic interface. Implemented CRUD operations in DAO layer. Applied T-SQL for complex DB operations, wrote SQL functions and stored procedures for repeated operations. Optionally applied some Advanced T-SQL techs such as Exception, Cursor and Trigger.
  • Used Jasmine and Karma to do front-end Angular Unit test, JUnit to do back-end API Unit test, JIRA to track the process of the project and joined the SCRUM meeting for report, Slack to communicate with team leader and members, Git and GitHub for Version Control and troubleshot with merge conflicts.

Environment: JavaScript ES6, HTML, CSS, Bootstrap, React, Redux, Git, Java Core, Spring MVC, JPA, SQL Server, Windows, and MAC OS X.

Confidential, MN

Java/J2EE Developer


  • Designed a J2EE Web application with Spring Core, Spring MVC architecture, JSP, Servlets, jQuery, Hibernate and Oracle.
  • Coded both front-end and back-end inside Eclipse under the created Dynamic Web Project structure by the project manager. Put All front-end JSP pages, JavaScript, CSS, and images under src/WebRoot directory
  • Utilized form submission or jQuery Ajax calls to call the required APIs inside Controller layer.
  • Developed back-end MVC architecture with Domain, Dao, Service, and Controller layers.
  • Wrote POJO classes, hibernated CRUD operations, business logics, REST API functions for front-end http requests under Domain, Dao, Service, and Controller layer respectively.
  • Applied Servlet Life Cycle Methods like init(), service(), doGet(), doPost() for Controller layers. Realized page redirection by using request.getRequestDispatcher().forward() with HttpServletRequest Class.
  • Configured Build Path by adding required external JARs for specific development. Configured hibernate.cfg.xml for database connection settings with several properties inside tag.
  • Realized Object relational Mappings (ORM) patterns (Mapping each POJO class to database columns) by creating a corresponding Hibernate Mapping file (hbm.xml) for each POJO class, or use Annotations inside POJO classes.
  • Extensively applied other Hibernate and database management technologies like Sessions, transactions, criteria queries, Hibernate Query Language (HQL), Native SQL, Cache, Batch Processing, and Interceptors to interact with the database.
  • Initialized Spring beans and called the bean xml files path by creating a new instance of ClassPathXmlApplicationContext class. Get the required bean with getbean() method under ApplicationContext class.
  • Developed some Spring customized Dependency Injections based on business logics.
  • Applied PL/SQL for complex DB operations and wrote SQL stored procedures for repeated operations.
  • Applied JUnit tool for writing Unit /Integration test cases. Used JIRA to track and report the issues in the application. Applied Git for Version Control and code management.

Environment: HTML, CSS, Bootstrap, JSP, Servlets, Git, Java Core, Spring Core, Spring MVC, Tomcat 7.0, Hibernate 4, Windows 7, and Oracle 11g.

Hire Now