NumberWorks'nWords

NumberWorks'nWords: Transforming Educational Technology

NumberWorks'nWords feature

A journey of technical growth and infrastructure transformation at New Zealand's leading educational technology company, where I evolved from a junior developer to a key technical contributor driving platform modernisation and performance optimisation.

Company Overview

NumberWorks'nWords operates as a franchise-based tutoring organisation across Australia and New Zealand and the United Kingdom, combining traditional in-centre learning with modern cloud-based education technology. The platform serves:

  • 70+ franchise centres with unique operational requirements
  • Thousands of students aged 5-16 across mathematics and English
  • Cloud-based learners accessing content remotely
  • Content creators developing interactive educational materials

Technical Evolution & Key Achievements

🏗️ Infrastructure Modernisation: Single EC2 to Containerised ECS

The Challenge:

NumberWorks'nWords operated successfully with their established franchise-based model across 70+ centres. When COVID-19 struck, there was an urgent need to rapidly deploy a cloud-based solution that could work alongside existing in-centre servers while serving remote students. The initial cloud infrastructure was quickly stood up on a large, under-utilised EC2 instance to meet immediate pandemic demands, but this created cost inefficiencies and operational challenges.

The deployment process involved manual file transfers, which led to inconsistent builds and frequent deployment issues. Load patterns were sporadic and unpredictable as the platform adapted to the new hybrid learning model, requiring a more resilient and cost-effective infrastructure approach.

My Solution:

I conducted a comprehensive system analysis, collaborating with stakeholders across the organisation to understand both technical requirements and business constraints. After aligning everyone on the vision, I architected a solution that addressed immediate cost concerns while building a foundation for long-term scalability. The transformation began with containerising the entire application using Docker, creating consistent, reproducible environments that could seamlessly sync between cloud and in-centre deployments.

# Docker containerisation with multi-stage builds
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
RUN npm run build

FROM node:18-alpine AS runtime
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY . .
EXPOSE 3000
CMD ["pm2", "start", "dist/server.js", "--name", "numberworks-n-words"]

The migration to AWS ECS enabled automated, zero-downtime deployments with auto-scaling and load balancing capabilities. This ensured the platform could gracefully handle varying loads, from quiet periods to high-traffic exam weeks when hundreds of students access content simultaneously. CloudFront integration improved content delivery speed for students across different geographical locations, while the migration to Amazon RDS enhanced data reliability with automated backups.

Building on the existing automated testing foundation, I optimised the CI/CD pipeline using GitHub Actions, reducing test execution time while improving reliability. This enhanced deployment pipeline ensured every code change was thoroughly validated before reaching production, providing confidence in the stability of updates.

Measurable Impact:

  • Deployment time: Reduced from 45 minutes to 5 minutes
  • Deployment success rate: Improved from 60% to 99.8%
  • System uptime: Increased from 95% to 99.9%
  • Developer productivity: Eliminated manual deployment steps for entire team

📊 Performance Optimisation: From Seconds to Milliseconds

The Challenge: Critical dashboard loading performance was severely impacting user experience:

  • Initial load time: 10+ seconds for tutor dashboards
  • Database bottlenecks: Inefficient queries on large datasets
  • API response times: 3-5 seconds for frequently accessed data
  • User frustration: Tutors unable to efficiently manage student progress

My Technical Solutions:

Multi-Layered Caching Architecture

// Hybrid caching system with Redis and local cache layers
export const removeFromCacheLayer = async (params) => {
  await cache().entities.remove(params);
  
  if (conditionalCheck(params)) {
    notifyRelatedSystems(params);
  }
  triggerCacheSync(params);
};

export const clearCacheByScope = async (scopeId) => {
  const cacheLayer = cache().scopedData;
  return cacheLayer.clear(scopeId);
};

export const removeFromMultipleCaches = async (params) => {
  await cache().primaryData.delete(params);
  await removeFromCacheLayer(params);
};

// Cache abstraction layer supporting multiple cache types
const cache = () => ({
  primaryData: {
    clear: (id) => Promise.all([
      redisCache.clear(`scope:${id}:data`),
      localCache.clear(`data:${id}`)
    ]),
    delete: (params) => Promise.all([
      redisCache.del(`entity:${params.id}`),
      localCache.del(`local:${params.id}`)
    ])
  },
  entities: {
    remove: (params) => Promise.all([
      redisCache.srem(`collection:${params.scope}`, params.id),
      localCache.invalidate(`entities:${params.scope}`)
    ])
  }
});

Database Optimisation

  • Table partitioning: Partitioned large student activity tables by date
  • Strategic indexing: Added composite indexes reducing query time by 95%
  • Query optimisation: Converted N+1 queries to efficient JOINs
  • CTE implementation: Used Common Table Expressions for complex reporting
-- A simplified example of an optimised student progress query with CTE
WITH student_activities AS (
  SELECT 
    student_id,
    lesson_id,
    completion_percentage,
    ROW_NUMBER() OVER (PARTITION BY lesson_id ORDER BY created_at DESC) as rn
  FROM student_lesson_progress 
  WHERE student_id = $1 AND created_at >= CURRENT_DATE - INTERVAL '30 days'
),
latest_activities AS (
  SELECT * FROM student_activities WHERE rn = 1
)
SELECT 
  l.title,
  la.completion_percentage,
  l.difficulty_level
FROM latest_activities la
JOIN lessons l ON la.lesson_id = l.id
ORDER BY l.sequence_order;

Performance Results:

  • Dashboard load time: Reduced from 10+ seconds to 100ms
  • API response time: Improved from 3-5 seconds to 50ms average
  • Database query performance: 95% improvement on critical queries
  • Cache hit rate: Achieved 85% cache hit rate on frequently accessed data

🚀 Frontend Optimisation & User Experience

React Component Optimisation:

// Implemented intelligent memoisation and lazy loading
const StudentDashboard = React.memo(({ studentId }) => {
  const { data: student } = useQuery(
    ['student', studentId],
    () => fetchStudent(studentId),
    { staleTime: 5 * 60 * 1000 } // 5-minute cache
  );

  return (
    <Suspense fallback={<DashboardSkeleton />}>
      <LazyStudentProgress studentId={studentId} />
    </Suspense>
  );
});

// Code splitting for reduced bundle size
const LazyStudentProgress = lazy(() => 
  import('./StudentProgress').then(module => ({
    default: module.StudentProgress
  }))
);

Advanced Compression Implementation:

  • Brotli compression: Implemented for API responses reducing bandwidth by 40%
  • Bundle splitting: Route-based code splitting reducing initial load
  • Image optimisation: WebP image conversion with fallbacks

🔧 DevOps & Quality Assurance

Staging Environment Creation: Established production-mirror staging and alpha environments enabling:

  • Safe feature testing before production deployment
  • Data consistency with automated production data sync
  • Performance testing under realistic load conditions
  • Cross-browser testing across multiple devices

Leadership & Mentorship

👥 Junior Developer Mentorship

  • Pair programming sessions: Pair programmed with the junior developer to help them understand the codebase and improve their skills
  • Code review: Reviewed code with the team to ensure quality and consistency
  • Technical documentation: Wrote comprehensive guides for complex platform features

🎯 Cross-Functional Collaboration

  • Stakeholder requirements gathering: reached out to stakeholders to understand their needs and requirements
  • Solution architecture: Presented technical solutions to non-technical stakeholders
  • Bug triage leadership: Coordinated rapid response for production issues
  • Knowledge sharing: Conducted technical presentations on platform improvements

Notable Project Contributions

Interactive Markdown Directive Components

Created reusable React components for educational content creators:

// Custom directive for interactive math problems
const MathProblem = ({ equation, hints, solution }) => {
  const [userAnswer, setUserAnswer] = useState('');
  const [showHint, setShowHint] = useState(false);
  
  return (
    <div className="math-problem">
      <Equation latex={equation} />
      <AnswerInput 
        value={userAnswer}
        onChange={setUserAnswer}
        onSubmit={() => checkAnswer(userAnswer, solution)}
      />
      {showHint && <HintDisplay hints={hints} />}
    </div>
  );
};

Platform Architecture Documentation

  • Mapped complex deployment differences between cloud and franchise environments
  • Created system architecture diagrams improving team understanding
  • Documented API integration patterns

Technical Skills Demonstrated

Backend Technologies

  • Node.js & Koa: RESTful API development and middleware creation
  • PostgreSQL: Advanced querying, indexing, and performance optimisation
  • Redis: Caching strategies and session management
  • AWS Services: ECS, RDS, CloudFront, S3, and IAM configuration

Frontend Development

  • React: Component optimisation, hooks, and context management
  • Performance: Bundle optimisation, lazy loading, and caching strategies
  • Testing: Unit testing with Vitest and integration testing
  • Build Tools: Vite configuration and optimisation

DevOps & Infrastructure

  • Docker: Multi-stage builds and container optimisation
  • CI/CD: GitHub Actions workflow design and implementation
  • Monitoring: Application performance monitoring and alerting
  • Security: AWS IAM policies and secure deployment practices

Business Impact

Operational Efficiency

  • Reduced support tickets by 60% through improved platform stability
  • Faster content deployment enabling rapid curriculum updates
  • Improved tutor productivity with responsive dashboard interfaces

Platform Reliability

  • 99.9% uptime serving thousands of daily active users
  • Zero-downtime deployments maintaining service continuity
  • Automated monitoring preventing issues before user impact

Links

  • 🌐 Company Website: numberworksnwords.com
  • 📊 Platform Performance: Serving 70+ centres across ANZ
  • 🎓 Educational Impact: Supporting thousands of students in mathematics and English

This role represents significant professional growth, transitioning from junior developer to technical leader while delivering measurable improvements in platform performance, reliability, and user experience.