Overview
Learnlight Platform & Mobile Apps — a scalable, multi-platform learning ecosystem supporting over 700,000 registered learners in 180+ countries. As a Full-Stack JavaScript Developer (Backend Focus), I worked on Learnlight's GraphQL abstraction layer (Apollo Server), optimising database access and data-loading behaviour to improve performance, stability, and developer experience across web and mobile.
With a background as an English trainer using the Learnlight platform, I brought valuable domain insight into how technical performance directly affected the learner experience. This perspective helped me identify and address bottlenecks that could impact usability and engagement.
My Role
I owned several key backend initiatives that strengthened the reliability and performance of Learnlight's learning platform.
- Introduced DataLoader to address the GraphQL N+1 query problem, reducing duplicate database calls from 36→1 per request and improving resolver response times by up to 70% for course-level queries.
- Optimised a complex data-heavy endpoint, cutting response time by over 65% through batching, caching, and query refactoring.
- Implemented GraphQL resolvers and raw SQL queries (via Sequelize) to support complex joins and analytics features, improving data retrieval efficiency for reporting services.
- Owned the full Oxford Learner's Dictionaries API integration — from discovery and contract to schema design, implementation, and rollout — adding in-app definitions and pronunciation features for learners.
- Implemented rate limiting for new SCORM integrations to safeguard backend services when deployed to large external training providers.
- Authored and consolidated API documentation directly within GraphQL schema definitions and Confluence, ensuring that new developers could configure and begin work as soon as their accounts were provisioned.
- Introduced a pre-commit test hook that automatically executed Mocha tests, preventing unverified code from being committed.
- Validated all GraphQL operations through a shared Postman collection, ensuring both request and response objects matched expected schemas prior to deployment.
- Acted as the API point of contact for mobile and web teams, leading backend discussions in sprint planning and clarifying delivery timelines.
- Conducted code reviews and applied domain knowledge from teaching on the platform to identify performance bottlenecks affecting learner experience.
Architecture and Approach
The backend was built around an Apollo Server-based GraphQL abstraction layer operating within the AWS VPC, positioned between the API Gateway and the PostgreSQL cluster. It served as the central interface for all web and mobile data requests, exposing multiple domains (Business, Worker, and Data Warehouse) through a unified, typed GraphQL API.
This layer handled the majority of data orchestration, applying batching (DataLoader), caching (Memcached), and selective rate limiting to optimise performance and reduce load on the underlying databases. Supporting services such as Lambda workers were used to offload compute-heavy operations, ensuring the platform remained stable at scale.
Data persisted primarily in PostgreSQL for transactional consistency, complemented by a MongoDB layer optimised for high-volume reads and reporting workloads. This combination provided flexibility for analytical queries and large-scale data retrieval without affecting core transactional performance.
I focused on application-level performance through query optimisation and efficient data access patterns, while collaborating with DevOps colleagues responsible for infrastructure monitoring, alerting, and system-level performance. Observability included New Relic APM instrumentation via the Apollo Server plugin for request tracing and resolver insights.
All new GraphQL fields and resolvers followed a clearly defined deprecation policy using the @deprecated directive, providing an eight-week window before removal. Schema changes were version-controlled in Git and underwent both automated (Mocha) and manual testing before hand-off to the QA team for final validation. Unit tests were mandatory for new work, covering input validation, resolver logic, and response structure.
To minimise breaking changes, schema updates followed a deprecate-then-remove policy with schema diff checks in CI and versioned field rollouts coordinated with iOS and Android teams.
Key Challenges and Solutions
| Challenge | Solution | Result |
|---|---|---|
| N+1 query problem causing redundant SQL calls | Introduced DataLoader for critical resolvers | Reduced duplicate queries 36→1; improved resolver speed by up to 70% |
| Slow performance for large, data-heavy queries | Refactored GraphQL resolvers with batching, caching, and optimised SQL | Cut response times by over 65% across key endpoints |
| High traffic from external SCORM integrations | Added rate limiting using rate-limiter-flexible | Safely handled load from large external deployments; validated limiter behaviour under controlled burst tests |
| Complex relational analytics queries | Created optimised raw SQL queries managed via Sequelize | Improved data retrieval efficiency and reduced query latency |
| Developer onboarding time | Consolidated API documentation and Postman collections | New developers could start building immediately after account setup |
| Quality assurance before commit | Added pre-commit hook to run Mocha tests automatically | Prevented untested code from entering the repository |
Technical Stack
- Languages & Runtime: Node.js, JavaScript (ES6+)
- Frameworks & Libraries: GraphQL (Apollo Server), DataLoader, graphql-rate-limit-directive, apollo-server-cache-memcached, Sequelize ORM
- Databases: PostgreSQL (transactional), MongoDB (read-optimised)
- Cloud & Integrations: AWS S3 (signed URL flows), AWS Secrets Manager, Oxford Learner's Dictionaries API
- Observability: New Relic APM (Apollo Server plugin), structured logging with Pino
- Testing & QA: Mocha, Chai, Postman (ServiceBroker collection), NYC (coverage), schema diff checks in CI
- Tooling: ESLint (Airbnb), Git Hooks (Pre-commit / CI gate)
- Collaboration & Workflow: Jira, Confluence, Bitbucket, VS Code, DBeaver, MS Teams
- CI/CD: GitLab CI/CD (organisation-level runners)
GDPR & Compliance
Completed formal GDPR awareness and compliance training:
- GDPR: Beginner (Kaspersky, Oct 2021)
- GDPR: Elementary (Kaspersky, Dec 2021)
- General Data Protection Regulation (GDPR) (Learnlight, May 2023)
- An Introduction to the GDPR (Kevin Mitnick Security Awareness, Mar 2024)
Applied these principles to backend development by minimising data exposure in dev/test environments and ensuring that GraphQL resolvers handled user data responsibly.
Security & Access Controls
- JWT-based authentication with one-hour token expiry.
- Development and test environments accessible only via OpenVPN for network isolation.
- Temporary AWS credentials issued through the AWS CLI for deployment access, reinforcing the principle of least privilege.
Impact
Helped maintain 99.94% uptime while supporting over 700,000 registered learners worldwide.
Optimised key GraphQL operations, reducing query counts and improving resolver performance, which enabled faster responses across web and mobile.
Improved development workflows through automated testing, pre-commit verification, and clear schema documentation, shortening onboarding time for new engineers.
Reflection
Working in a small backend team provided full exposure to the platform's data architecture — from SQL and GraphQL optimisation to schema evolution and developer tooling. Owning initiatives such as the DataLoader rollout, dictionary integration, and test automation strengthened my expertise in building scalable and maintainable backend systems that balance performance, reliability, and collaboration.
Within a team of around ten, I regularly facilitated backend planning discussions and acted as the point of contact for API-related workstreams, ensuring technical feasibility and realistic delivery timelines.
I also contributed to code reviews, applying both technical and domain knowledge to identify bottlenecks that could affect user experience or learning outcomes.