Java Developer Stack

Sonali B

Full Stack Java Developer

***********@*****.*** +1-901-***-**** Linkedin

PROFESSIONAL SUMMARY

•Full Stack Java Developer with more than 10+ years of hands-on professional experience in all phases of software development.

•Improved backend performance by leveraging Java 8 and Java 17 features like Streams and Lambda expressions, optimizing systems built with J2EE, EJB, JSP, JSF, Servlets, Java Beans, and ORM frameworks.

•Changed and rebuilt a large application into microservices using Spring Boot 3 and Spring Cloud, which made the system more reliable and easier to scale.

•Built RESTful APIs with Node.js (Express.js) for a busy financial platform, and wrote Python scripts for automation and data processing. Strengthened platform security by implementing Spring Security, OAuth2, and JWT.

•Created reliable REST and RPC style APIs that helped systems communicate securely and efficiently.

•Applied REST Concepts and HTTP knowledge to build fast and scalable APIs for heavily-used platforms.

•Created and updated responsive front-end interfaces for finance and ecommerce applications using Angular (16, 8, 5, AngularJS) and ReactJS, making sure applications worked smoothly on all devices and platforms.

•Developed dynamic, responsive web applications using JavaScript, TypeScript, HTML5, and CSS, leveraging frontend tools like Bootstrap and Material-UI. Improved front-end maintainability, scalability, and performance across multiple finance and e-commerce platforms.

•Built and improved relational databases (PostgreSQL, MySQL, Oracle), making queries 40% faster while keeping data accurate and consistent.

•Worked with NoSQL databases including MongoDB, Cassandra, and DynamoDB for large-scale data management in a Big Data project, which made data access quicker.

•Used Redis and Memcached for caching, which made web applications respond faster during high-traffic periods.

•Built scalable cloud solutions using AWS services including Lambda, S3, and DynamoDB to meet complex business needs and improve system capabilities.

•Developed and deployed cloud-native applications on AWS, Azure, and GCP, ensuring scalability, reliability, and high availability.

•Worked with PostgreSQL databases on GCP, AWS RDS, and Amazon Aurora, making improvements to database speed and maintaining data quality.

•Created and ran automated tests for Java applications and APIs using JUnit, TestNG, and Postman which improved software quality and helped release updates faster.

•Practiced Test-Driven Development (TDD) and used Mockito to simulate external systems, helping build clean and easy-to-maintain code.

•Built and automated end-to-end testing frameworks using Cypress for front-end validation and Selenium WebDriver for cross-browser testing, improving application reliability and deployment speed.

•Added OAuth2, JWT, and Single Sign-On (SSO) security to microservices systems, which improved protection against unauthorized access.

•Set up Apache Kafka and RabbitMQ to enable real-time and asynchronous data flow between microservices, improving system reliability by 40% and ensuring consistent communication under high traffic loads.

•Designed and implemented CI/CD pipelines using Jenkins for automated builds and deployments, and used Docker to containerize applications, ensuring consistent environments across development, testing, and production.

•Built and set up Service Bus Network (SBN) solutions to enable secure and efficient communication between distributed systems

•Built messaging systems using IBM MQ to handle secure messaging between enterprise applications, using its features for transaction and event-based communication.

•Enhanced system efficiency by reducing CPU utilization by 20% during high-traffic periods, while ensuring seamless integration with Web Services (SOAP and REST), JDBC operations, XML parsing, and front-end technologies like CSS.

•Implemented Prometheus and Grafana dashboards for proactive system monitoring, while using the ELK Stack to collect, analyze, and visualize logs, enhancing overall platform reliability and issue resolution speed.

•Developed and enhanced applications by following the complete Software Development Life Cycle (SDLC). Applied Agile methodologies, Scrum practices, and Test-Driven Development (TDD) to ensure high-quality and timely delivery.

•Guided teams using Scrum and Kanban methods while managing code with Git, Bitbucket, and GitLab, which helped teams deliver work faster and more efficiently

TECHNICAL SKILLS

Programming Languages: Java (Core Java, Java 8,11,17), JavaScript (ES6+), TypeScript, Python, SQL, PL/SQL.

Web Technologies: HTML5, CSS3, jQuery, AJAX, Bootstrap, DOM, XHTML, Material-UI.

Front-End Frameworks: Angular (8, 5, AngularJS), ReactJS, Redux, React Router, Vue, Svelte

Back-End Frameworks: Spring Boot, Spring Cloud, Spring MVC, Spring Security, Spring Data JPA, Hibernate ORM, Node.js, Express.js, Django.

Microservices & API Development: RESTful APIs, SOAP, gRPC, GraphQL, Swagger.

Containerization & Orchestration: Docker, Kubernetes, Helm.

CI/CD & Build Tools: Jenkins, GitHub Actions, Maven, Gradle, Gulp, NPM.

Cloud Platforms: AWS (EC2, S3, Lambda, ECS, API Gateway, IBM WebSphere, RDS, IAM), Azure (Blob Storage, Virtual Machines, Functions, API Management), Google Cloud Platform (GCP).

Database Management: MySQL, PostgreSQL, MongoDB, Cassandra, Oracle, Redis.

Logging & Monitoring: Log4j, JProfiler, New Relic, Prometheus, Grafana, ELK Stack (Elasticsearch, Logstash, Kibana), Kibana.

Messaging & Streaming: Apache Kafka, RabbitMQ, Autosys, AMQP.

Agile & DevOps: Agile methodologies (Scrum), JIRA, Git, Bitbucket, GitLab, CI/CD.

Testing & Debugging: Jasmine, Karma, Protractor, JUnit, Mockito, Cucumber, Selenium WebDriver.

Other Tools & Technologies: Eclipse IDE, IntelliJ IDEA, Visual Studio Code, Infrastructure as Code (IaC) with Terraform.

PROFESSIONAL EXPERIENCE

American Express: July 2024 - Current (Location: NY, Newyork)

Senior Full Stack Developer

•Developed Java-based RESTful APIs integrated with Spring Boot to enhance data flow across AMEX TAP modules, improving system scalability while maintaining robust security standards using Java frameworks.

•Implemented microservices architecture with Java and Spring Boot 3 for real-time transaction analytics, ensuring faster request processing and consistent service delivery across Java-driven financial applications.

•Engineered RESTful APIs using Kotlin to connect customer account services; improved Kotlin module error handling to deliver consistent and reliable transaction data to AMEX TAP platform users.

•Migrated legacy Java applications to Kotlin, improving readability and reducing boilerplate code, while maintaining compatibility by combining Kotlin modules with existing Java frameworks during the transition phase.

•Updated the provider's portal from a monolithic system to Microservices using Spring Boot 3 & Spring Cloud. Built RESTful APIs with Spring MVC to connect financial and pay systems.

•Built backend services using Node.js for real-time transaction analytics, connecting financial microservices with Node.js APIs to improve platform efficiency, scalability, and customer experience across AMEX TAP systems.

•Connected frontend systems with Spring Boot and RESTful APIs to handle data processing and provide real-time updates to users.

•Built microservices with Spring Boot 3, using Spring Data JPA and Spring Security with OAuth2 to protect sensitive mortgage data and meet industry security standards.

•Built fast REST and gRPC APIs for secure payment processing, fraud detection workflows, and customer account services, enabling efficient and reliable communication between microservices.

•Built and maintained fast, responsive application interfaces using React, Bootstrap, HTML5, CSS3, and AJAX. Made sure applications worked smoothly across different web browsers and financial platforms.

•Built dynamic dashboards using Next.js for real-time financial data visualization. Optimized Next.js server-side rendering to deliver faster load times and seamless analytics across AMEX TAP modules.

•Created secure login and user onboarding flows with Next.js in AMEX TAP systems. Enhanced Next.js authentication handling using OAuth2 and session management best practices for financial applications.

•Developed Single Page Applications with React for tracking provider portals and payment processing in real-time, which improved how users interact with the system.

•Used React UI components and themes to build responsive, easy-to-use interfaces that helped users navigate applications more efficiently.

•Created financial fraud detection algorithms using Python and integrated them into microservices; improved Python machine learning workflows to analyze transaction anomalies for AMEX TAP analytics platform.

•Designed high-availability clusters for MongoDB and optimized complex queries in PostgreSQL, enabling scalable mortgage analytics systems that utilized both MongoDB document stores and PostgreSQL relational structures.

•Built ETL pipelines to move data between MongoDB, PostgreSQL keeping data accurate and consistent across all databases.

•Modernized mortgage data infrastructure by integrating Azure SQL Database with PostgreSQL, ensuring fault tolerance and high availability across regions using Azure cloud resilience features for critical transaction systems.

•Automated ETL pipelines to sync customer records between legacy systems and Azure Data Factory, optimizing data consistency and leveraging Azure for scalable ingestion in the AMEX TAP analytics platform.

•Enhanced backend reliability by configuring microservices to store logs and telemetry on Azure Monitor, enabling proactive troubleshooting and deep performance insights through Azure-native observability dashboards.

•Streamlined cloud architecture by orchestrating API microservices and Kafka flows with Azure Kubernetes Service (AKS), improving scalability and managing workloads efficiently on Azure during transaction surges.

•Created and ran unit and integration tests using JUnit, Mockito, and Vaadin TestBench. Used TDD methods to ensure reliable Claims management, billing, and coding.

•Used Apache Kafka to handle real-time data flow between microservices, which made the mortgage data processing system 40% more reliable.

•Implemented monitoring for Apache Kafka clusters using Grafana and Kibana, tracking key performance indicators for Apache Kafka to quickly detect bottlenecks and optimize mortgage transaction throughput.

•Built real-time data processing microservices using Scala on Kafka streams; improved Scala application throughput to support faster financial transaction analytics across the AMEX TAP platform.

•Built real-time transaction services using Docker for containerization and orchestrated deployment through Kubernetes. Streamlined Docker workflows and integrated Kubernetes monitoring to ensure system resilience.

•Created CI/CD pipelines using GitHub Actions and Jenkins to automate code building, testing, and deployment. Used Terraform to automatically set up and manage cloud resources on Azure.

•Developed and automated microservice builds with Gradle, improving packaging and version management. Configured multi-project setups in Gradle to support seamless deployment for transaction analytics modules.

•Used Redis and Memcached caching to speed up response times and improve performance for mortgage applications with high user traffic.

•Built and deployed GraphQL APIs that allowed more efficient querying of Labs data, making it easier for front-end systems to fetch exactly the data they needed.

•Managed real-time application logs using ELK Stack, setting up centralized log aggregation with ELK to efficiently monitor financial transactions and debug system anomalies across microservices.

•Built centralized logging using ELK Stack to capture application events, with ELK Stack dashboards helping teams troubleshoot real-time transaction anomalies and maintain consistent system uptime across financial platforms.

•Set up Kibana alerts to track important metrics and find performance issues in Kafka clusters that process mortgage applications in real-time.

•Created and maintained incident response procedures, including automatic alerts and fixes to keep applications running smoothly with high performance.

•Developed scalable document indexing pipelines with Apache Solr to support dynamic mortgage and payment datasets; enhanced Apache Solr query parsing to boost system efficiency during peak loads.

•Delivered scalable microservices within Agile project frameworks by integrating sprint demos and velocity tracking, optimizing Agile delivery timelines to meet critical payment processing and onboarding service milestones.

•Participated in Scrum ceremonies including retrospectives and backlog grooming, continuously refining sprint goals and aligning Scrum team priorities to improve transaction analytics platform performance and customer satisfaction.

Environment: Java 17, Kotlin, Spring Boot 3, Spring Cloud, Spring MVC, Spring Security, React, OAuth2, Azure, Vaadin 21+, Azure SQL Database, Azure Monitor, PostgreSQL, Docker, AKS, GitHub Actions, Jenkins, Terraform, Kafka, JUnit, Mockito, Swagger, Kibana, Grafana, Redis, Memcached, GraphQL, Prometheus, ELK Stack, Apache Solr, MongoDB, Oracle DB

Amazon: July 2022 - June 2024 (Location: Seattle, WA)

Senior Full Stack Developer

•Developed scalable backend microservices using Java and Spring Boot, optimizing transaction processing in the Customer Advisor Tool with real-time event streaming handled via Java applications integrated with Apache Kafka.

•Improved backend application speed by using Java Streams and Java Lambda expressions, enhancing transaction processing efficiency and reducing CPU consumption during high-volume Customer Advisor Tool operations.

•Built microservices using Kotlin and Spring Boot, enhancing backend service scalability and leveraging Kotlin coroutines to manage concurrent API requests more efficiently in a cloud environment.

•Enhanced system reliability by deploying distributed Spring Boot microservices on Kubernetes clusters, implementing autoscaling and monitoring strategies to ensure continuous availability of all critical Spring Boot services.

•Built secure backend microservices with Spring Boot and Java 17, implementing Spring Security modules and Java OAuth 2.0 integration to enhance authentication and authorization in the Customer Advisor Tool.

•Designed robust backend architecture using Spring Boot microservices, integrating Kafka event streams and AWS Lambda to support real-time processing workflows developed through the Spring Boot framework.

•Designed efficient APIs using Node.js to handle high-volume customer requests, implementing scalable microservices architecture and optimizing Node.js event-driven capabilities for faster transaction processing in a cloud-native environment.

•Developed middleware solutions with Node.js for secure API gateway integrations, ensuring efficient service-to-service communication and enhancing data encryption practices through robust Node.js libraries and security frameworks.

•Created robust REST services with token-based authentication, encrypting REST API requests using HTTPS and applying OAuth 2.0 standards to protect critical customer transaction data in real-time systems.

•Built responsive user interfaces with Angular for Customer Advisor Tool, focusing on cross-browser compatibility and smooth user experience.

•Created advanced UI components using Angular Material and Bootstrap to display real-time financial data effectively and improve the platform's visual design.

•Improved front-end speed through lazy loading, code splitting, and caching strategies, which reduced page load times by 30% and made the application more responsive.

•Integrated Hibernate ORM to manage database operations, enabling efficient data storage and retrieval in the Customer Advisor Tool backend system.

•Automated data extraction workflows using Python scripts and built data pipelines by integrating AWS services, leveraging Python libraries like Pandas and Boto3 for processing and storage.

•Created optimized SQL queries and implemented database indexes, significantly improving data retrieval speed across the application.

•Built and refined complex SQL queries and stored procedures in Oracle databases, enhancing financial application performance.

•Developed automated ETL processes using PL/SQL in Oracle, creating efficient data pipelines between financial systems.

•Structured large-scale datasets in MongoDB and tuned MongoDB query performance by creating compound indexes and shard keys, ensuring faster access to transactional and customer-facing business data.

•Set up and managed PostgreSQL and Oracle databases using AWS RDS, implementing automated backups and multi-AZ deployments. Configured read replicas and optimized database parameters to ensure data durability and consistent performance during high-load periods.

•Implemented and configured Redis caching system to store frequently accessed data, reducing database load and improving application performance.

•Built and deployed scalable applications on AWS using EC2, Auto Scaling, and Elastic Load Balancing (ELB) to support high-volume customer interactions and peak e-commerce traffic. Implemented robust infrastructure and monitoring to maintain application availability and performance across multiple availability zones.

•Developed serverless financial workflows using AWS Lambda and AWS API Gateway, implementing event-driven architectures to optimize Customer Advisor Tool operations and improve system responsiveness during peak loads.

•Integrated real-time monitoring and alerting with AWS CloudWatch and AWS SNS, automating system health checks, resource scaling, and proactive incident notifications for the Customer Advisor Tool environment.

•Created serverless applications using AWS Lambda and API Gateway for efficient financial data processing. Developed event-driven architectures to automate workflows and reduce infrastructure management overhead while improving system responsiveness.

•Created automated unit tests with JUnit and Mockito frameworks, maintaining comprehensive code coverage and improving code quality. Integrated continuous testing pipelines to catch defects early in the development cycle and ensure stable code releases.

•Created reusable testing components in Cypress to validate critical user workflows, while using Selenium to simulate complex user interactions, improving the reliability of Cypress and Selenium automation suites.

•Utilized Kafka to design real-time event-driven pipelines, enabling the Customer Advisor Tool to process transactions instantly by integrating Kafka with Java 17 microservices during AWS migration.

•Developed seamless data communication using Kafka for microservices, optimizing message streaming between backend components, and ensured Kafka durability for high-volume transactional workflows.

•Used Git for version control and collaborated through GitHub, streamlining code reviews and feature merges with team members. Established branching strategies and maintained clean commit histories to support parallel development across multiple features.

•Built Docker containers for microservices to standardize environments across development, testing, and production stages. Created optimized Docker files and implemented multi-stage builds to reduce container image sizes and improve deployment efficiency.

•Managed microservices deployment and scaling using Kubernetes to support the Customer Advisor Tool. Configured auto-scaling, resource quotas, and readiness probes to ensure consistent performance during peak shopping and transaction periods.

•Configured Nginx for load balancing and scaling to maintain consistent application performance during high traffic periods. Implemented caching strategies, SSL termination, and rate limiting to enhance

•Optimized backend microservices by configuring Maven plugins for code quality checks and leveraging Maven lifecycles for seamless application packaging, significantly improving delivery speed and reducing manual errors.

•Monitored microservices performance using Prometheus for metrics collection and visualized system health with Grafana, improving observability across Customer Advisor Tool deployments through enhanced Prometheus and Grafana dashboards.

•Configured Prometheus to scrape metrics from Java Spring Boot services and integrated Grafana to create dynamic visualizations, ensuring continuous application monitoring with customized Prometheus and Grafana alerts.

•Prioritized defect fixes and feature enhancements using Agile tracking tools like Jira, ensuring clear visibility of Java Spring Boot development progress within the broader Agile project management framework.

Environment: Angular, NPM, Gulp, Node.js, Express.js, MySQL, Oracle, MongoDB, Core Java, Stream API, Spring Boot, Hibernate ORM, Spring Security, OAuth2, JWT, Spring MVC, GraphQL, Flask, Django, MongoDB, MySQL, PostgreSQL, SQL, Cassandra, Oracle WebLogic, AWS, Docker, Kubernetes, Azure Functions, API Management, GitHub Actions, Jenkins, GDPR, Terraform, RabbitMQ, Kafka, Prometheus & Grafana, Jasmine, Mockito, JUnit, Maven, Swagger, Redis caching, JProfile, Log4j, Git, Bitbucket

Mastercard: December 2018 - June 2022 (Location: Purchase, NY)

Full stack Java Developer

•Built secure payment microservices using Java and Spring Boot, applying Java multi-threading techniques to efficiently handle large-scale financial transactions across Mastercard’s global transaction management system.

•Improved database operations with optimized Java persistence strategies using Spring Data JPA, enhancing Mastercard’s transaction processing speed by fine-tuning Java ORM entity mappings.

•Designed and implemented microservices using Java Spring Boot and integrated secure APIs with Java OAuth2, strengthening Mastercard’s financial transaction systems with high performance and controlled user access.

•Created enterprise applications using Spring Boot, Spring Data JPA, Spring MVC, Spring IOC, and Spring AOP to ensure reliable and easy-to-maintain systems.

•Added Microservices to the existing system. Built Microservices business components and RESTful APIs using Spring Boot to improve system speed and handling of increased users.

•Used Spring IOC for Dependency Injection and Spring AOP for logging to reduce code coupling and manage shared application tasks.

•Built responsive UI dashboards using React components with TypeScript, improving usability across devices; reused React hooks and context APIs to simplify state management in transaction monitoring workflows.

•Developed interactive forms and visual flows with React, supporting real-time approval tracking; used React lifecycle methods to manage updates efficiently during high-frequency payment events.

•Implemented reusable UI libraries in React and integrated with Spring Boot APIs; maintained consistency in React styling across modules using Material-UI and Bootstrap frameworks.

•Customized dynamic tables and filters with React for settlement history views; optimized rendering in React by applying memoization and conditional rendering to handle heavy financial datasets.

•Built and optimized SQL databases for financial transaction systems, applying data integrity rules, normalization techniques, and efficient queries to support high-volume processing and reporting needs.

•Created advanced SQL queries, stored procedures, and functions in SQL Server that improved data access and reporting speed, making financial systems run faster and handle more users.

•Designed optimized data schemas in PostgreSQL and implemented indexing strategies to reduce query latency; wrote complex joins and views in PostgreSQL to support real-time financial transaction insights.

•Developed backend services with Spring Boot that performed transactional updates in PostgreSQL; enforced ACID compliance through PostgreSQL constraints to ensure consistent financial data across distributed systems.

•Added MongoDB to store unstructured data in a microservices system running in the cloud, using its flexible document model to support growing data needs.

•Deployed microservices using GCP App Engine and secured endpoints with Spring Security; integrated GCP Cloud SQL for transactional workloads, ensuring consistent performance during high-load financial processing.

•Maintained hybrid cloud reliability by building messaging pipelines with Kafka and syncing GCP Pub/Sub; designed distributed failover patterns across GCP and AWS for uninterrupted transaction processing.

•Configured secure data exchange between Mastercard's cloud microservices using GCP API Gateway; built Spring Boot APIs aligned with PCI-DSS while logging events to GCP Operations Suite for audit compliance.

•Improved system observability using GCP Stackdriver with real-time metrics and error tracking; enabled fault diagnostics and alerts by integrating GCP logging with Jenkins-based CI/CD pipelines.

•Created and ran automated unit tests with JUnit and Mockito for Java programs, reaching 90% code coverage and catching bugs before they reached production.

•Built and maintained Selenium and Cypress test suites to ensure web applications functioned correctly across different browsers. Helped deliver a smooth and consistent user experience through automated end-to-end testing.

•Integrated RabbitMQ to manage inter-service communication between microservices, ensuring reliable message delivery and high system scalability. Optimized RabbitMQ configurations to support financial transaction loads across Mastercard Secure Transaction Management System.

•Developed messaging patterns using RabbitMQ to decouple backend services and improve transaction consistency. Tuned RabbitMQ queues to achieve better fault tolerance and faster recovery in Mastercard's payment systems.

•Established automated pipelines integrating CI/CD processes with Jenkins and GitHub, maintaining efficient CI/CD workflows to enable smooth deployments of Java microservices across Mastercard’s secure transaction platform.

•Containerized Java microservices using Docker for consistent development and production environments, orchestrating scalable deployments with Docker images across Mastercard’s cloud-based transaction management system.

•Automated microservice deployment using Kubernetes, applying rolling updates and Kubernetes health checks to ensure Mastercard’s financial systems remained operational during version upgrades and peak traffic loads.

•Developed REST APIs and secured transaction services using Spring Boot, managing project dependencies efficiently through Maven. Applied Maven multi-module structure to streamline code sharing across financial services.

•Integrated ELK Stack for centralized log analysis of microservices, capturing real-time payment logs; configured ELK pipelines to parse structured and unstructured logs for transaction error tracing.

•Built monitoring dashboards in ELK to visualize system health across regions; used ELK alerts to notify transaction failures, reducing detection time during peak settlement periods.

•Built SOAP based JAX-WS Web services to connect different systems together, making code reusable, and tested performance with JMeter.

•Delivered transaction features by closely collaborating within Agile Scrum teams, refining Mastercard sprint goals through daily Agile Scrum ceremonies including stand-ups, sprint planning, and retrospectives.

Environment: jQuery, React, Bootstrap, TypeScript, Spring Boot, Microservices, Spring Data JPA, Spring MVC, Spring IOC, Spring AOP, Spring Security, OAuth2, Python, Django, jQuery UI, SOAP, JAX-WS, JMeter, RESTful web services, XML, JSON, Jersey, MongoDB, CRUD operations, JMS server, WebSphere Server, Continuous Integration (CI), Continuous Development (CD), Jenkins, Maven, ELK Stack, GitHub, JUnit, Kubernetes, GCP Cloud SQL, PostgreSQL, Google Cloud Platform (GCP), Google Cloud Storage, Compute Engine, Cloud SQL, GitLab, Pandas, Django, Matplotlib, Seaborn

AT&T: December 2015 - November 2018 (Location: Dallas, TX)

Full stack Developer

•Built and delivered web applications that met all functional requirements and project specifications within deadlines.

•Created JavaScript code for client-side form validation and input handling. Built responsive user interfaces with HTML, JSP, and jQuery to create efficient, interactive web pages.

•Used Apache Struts framework to implement MVC patterns for web components, improving code organization. Developed server-side features using Java EE, Spring Framework, and Hibernate, connecting them with MySQL databases.

•Set up and managed application deployments on Apache Tomcat and WebLogic Application Server to ensure stable performance and scalability. Wrote transaction handling code in the Data Access Layer to maintain data consistency.

•Tested code functionality using JUnit to verify application behavior and maintain code quality. Implemented Log4J logging throughout the application to track errors, information, and debug messages for easier maintenance.

•Created transaction handling logic with Spring Data JPA and Hibernate to manage complex data operations and maintain database consistency.

•Built authentication and authorization features using Spring Security to control access and protect application resources.

•Implemented cloud solutions using Amazon Web Services (AWS), setting up EC2 instances for computing needs and S3 buckets for data storage.

Environment: Java 7, Java EE, JSP, Servlets, Spring Framework, Spring Data JPA, Hibernate, Apache Struts, MySQL, Apache Tomcat, WebLogic Application Server, RESTful and SOAP Web Services

Contact this candidate