Skip to main content
Software Developer · Signovate Technologies Pvt. Ltd.

A. Akash Achary

Software Developer building reliable backend systems in Java and Spring Boot — from service architecture to the production concerns that keep them running: observability, testing, and failure handling.

JavaSpring BootSpring Data JPAHibernateREST APIsApache Kafka
ClientAPI GatewaySpring Boot ServiceKafkaRedisDatabaseMonitoring

Hover or tab through a node to see what it does.

Backend-first, full-stack when it matters

Akash is a backend-focused software developer with about three years of professional experience, currently building services at Signovate Technologies. His work centers on Java and Spring Boot: designing REST APIs, modeling data with JPA/Hibernate, and reasoning about the distributed-systems problems that show up once a service stops being a toy — message ordering, retries, caching, and observability. He also works comfortably across the stack when a project calls for it, including React/Node full-stack builds and applied computer-vision work.

Education

B.Tech in Information Technology

NIST University

Education

Diploma in Mechanical Engineering

Gandhi Polytechnic College

Where the work has actually happened

AUG-2023 — Present

Current

Software Developer

Signovate Technologies Pvt. Ltd.

Backend development on Java/Spring Boot services: REST API design, data persistence with JPA/Hibernate, microservice patterns, and the day-to-day production work of testing, debugging, and monitoring services after they ship.

  • Designing and implementing REST APIs with Spring Boot
  • Service-layer and repository-layer design with Spring Data JPA / Hibernate
  • Working with relational databases (MySQL, Oracle) and query design
  • Applying microservice patterns and inter-service communication
  • Writing tests with JUnit and Mockito; BDD scenarios with Cucumber
  • Instrumenting services for observability (logging, monitoring)
  • Working with containerized environments (Docker) and cloud infrastructure (AWS)

Specific client names, team size, and business metrics are internal to Signovate and are not published here.

Engineering case studies, not screenshots

Each project below breaks down the problem, the architecture, and the decisions behind it.

A backend-weighted toolkit

Grouped by how central each area is to Akash's day-to-day work — not an alphabetical dump.

Core Backend

core
JavaSpring BootSpring Data JPAHibernateREST APIsMicroservicesMavenJava Concurrency / MultithreadingObject-Oriented Design

Messaging & Distributed Systems

core
Apache KafkaRabbitMQRedis

Databases

core
MySQLOraclePostgreSQLSQLMongoDBMongoDB Atlas

Security

JWTOAuth2Spring Security

Cloud & Infrastructure

AWSAzureDockerKubernetesTerraform

Testing

JUnitMockitoSonarQubeCucumber (BDD)SoapUI

Observability & Operations

PrometheusNew RelicELK StackLogbackLog4j2

API & Dev Tools

Swagger / OpenAPIGitGitHub

Frontend & Full Stack & Languages

JavaPythonSQLGoMERN StackNode.jsJavaScriptReactAngularViteHTMLCSSNode.jsExpress.js

How I think about software

Boundaries before code

Before writing a service, decide what it owns and what it explicitly doesn't. Most painful coupling later traces back to a boundary that was never actually drawn.

Observability is part of the feature

A service isn't done when it handles the happy path — it's done when you can tell, from logs and metrics, why it failed at 3am without reading the code.

Async by default at the seams

Anywhere two services meet, prefer an event over a synchronous call unless there's a real reason for a blocking dependency. It's easier to add synchronicity later than to remove it.

Tests describe intent, not implementation

A good test should survive a refactor. If changing internals breaks tests that never touched the behavior being changed, the tests were coupled to the wrong thing.

Data models outlive the code around them

Schemas and message formats are the hardest thing to change in a running system. Worth spending real time on before the first migration ships.

Debugging is a skill, not a fallback

Reproducing an issue reliably before touching code is usually faster than guessing — even when guessing feels faster in the moment.

Have a backend problem worth solving?

Open to backend / Java / Spring Boot roles. The fastest way to reach me is email — happy to walk through any project on this site in more depth.