Features#

Overview#

This section documents the features in the California Accountability Panel application, organized as Features (F1-F8) and following Agile-ish development methodology. Each Feature represents a major user-facing capability built to address specific stakeholder needs in K-12 educational accountability and data transparency.

Our feature architecture follows industry best practices in software engineering:

  • Component-Based Design: Reusable UI components with clear separation of concerns

  • Data-Driven Development: Features directly map to California Department of Education (CDE) accountability metrics

  • Accessibility-First: WCAG 2.1 AA compliance ensures equitable access for all users

  • Privacy by Design: FERPA-compliant data suppression rules protect student identities

Feature Roadmap#

Feature Development Status#

Feature

Name

Status

Learning Focus

F1

ELA Academic Performance Dashboard

Planned

Scale score trends, performance levels, longitudinal cohort analysis

F2

Mathematics Academic Performance Dashboard

Planned

Data normalization, performance band visualization

F3

Science (CAST) Academic Performance

Planned

Multi-grade aggregation, multi-year trend analysis

F4

English Learner Progress (ELPAC)

Planned

Proficiency level growth, reclassification logic

F5

Chronic Absenteeism Tracking

Planned

Time-series analysis, risk indicators, early warning algorithms

F8

Suspension Rate Explorer

Planned

Ratio calculations, subgroup disparity detection

F7

Graduation Rate Dashboard

In Progress

Cohort models (4-, 5-, 6-year), statistical rate calculations

F8

A-G Completion and College/Career Readiness

Planned

Multi-metric aggregation, readiness scoring engine

Architecture Principles#

1. Separation of Concerns

Each Feature (F1-F8) is further implemented using components. This two-tier hierarchy ensures:

  • Maintainability: Changes to one component don’t cascade across the system

  • Testability: Each layer can be unit tested independently

  • Scalability: New features can be added without refactoring existing code

  • Reusability: Components are shared across multiple features

2. Domain-Driven Design

Features map directly to educational accountability domains:

  • Academic Performance (English Language Arts, Mathematics, Science)

  • Student Support (English Learner Progress, Chronic Absenteeism)

  • School Climate (Suspension Rates)

  • College & Career Readiness (Graduation Rates, A-G Completion)

This alignment ensures the codebase mirrors the mental model of our primary users: educators, administrators, and policymakers.

3. Progressive Enhancement

Features are built with a “progressive enhancement” approach:

  • Base Layer: Semantic HTML providing core functionality

  • Enhancement Layer: CSS for visual presentation and responsive design

  • Interaction Layer: JavaScript for dynamic features (sorting, filtering, trend charts)

This ensures accessibility for users with varying device capabilities and assistive technologies.

Educational Value for K-12 Computer Science Curriculum#

This project serves as an excellent real-world case study for teaching computer science concepts to K-12 students:

For Middle School (Grades 6-8):

  • Data Structures: Understanding how student performance data flows from CSV files to visual displays

  • Algorithms: Introduction to sorting algorithms through interactive data tables

  • User Interface Design: Principles of accessible, inclusive design for diverse users

  • Computational Thinking: Breaking down complex problems (educational equity) into manageable features

For High School (Grades 9-12):

  • Software Architecture: Component-based design patterns and modular programming

  • Web Technologies: HTML, CSS, JavaScript, React framework, FastAPI backend

  • Data Privacy & Ethics: FERPA compliance, data suppression rules, ethical considerations in displaying student data

  • Version Control: Git workflow, documentation-as-code, collaborative development

  • API Design: RESTful principles, data ingestion from California Department of Education APIs

  • Database Design: SQL schema design for storing accountability metrics

  • Testing: Unit tests, integration tests, accessibility testing with WCAG standards

Cross-Curricular Connections:

  • Social Studies: California education policy (LCFF, LCAP, Dashboard accountability)

  • Mathematics: Statistical analysis, percentiles, year-over-year change calculations

  • Civics: Public data transparency, parent/guardian participation in school improvement

  • Ethics: Balancing transparency with student privacy protection

Learning Pathways#

Students can engage with this codebase at multiple skill levels:

Beginner (No Prior Coding Experience):

  1. Explore the deployed application interface

  2. Analyze how color-coded indicators communicate performance levels

  3. Identify user personas and their information needs

  4. Create wireframes for new features using design tools

Intermediate (Some HTML/CSS/JavaScript):

  1. Fork the repository and set up local development environment

  2. Modify CSS styles to improve visual hierarchy

  3. Add new accessibility features (keyboard navigation, ARIA labels)

  4. Write documentation for existing components

Advanced (Full-Stack Development):

  1. Implement new performance metrics (e.g., ELPAC proficiency levels)

  2. Build data visualization components using D3.js or Chart.js

  3. Create API endpoints for custom data queries

  4. Design and implement database migrations for new accountability measures

  5. Write comprehensive test suites with high code coverage

Technical Stack (Learning Opportunities)#

Frontend:

  • React 18+: Component lifecycle, hooks, state management, virtual DOM

  • TypeScript: Type safety, interfaces, generics

  • Tailwind CSS: Utility-first CSS, responsive design, component composition

  • Accessibility: ARIA roles, keyboard navigation, screen reader compatibility

Backend:

  • Python 3.13+: Modern Python features, type hints, async/await

  • FastAPI: REST API design, dependency injection, automatic API documentation

  • SQLAlchemy: ORM patterns, database migrations, query optimization

  • Pydantic: Data validation, serialization, API schemas

DevOps & Tooling:

  • Docker: Containerization, microservices architecture

  • Git/GitHub: Version control, pull requests, code review process

  • Sphinx: Documentation-as-code, reStructuredText markup

  • pytest: Test-driven development, fixtures, mocking

Data Processing:

  • Pandas: Data manipulation, cleaning, aggregation

  • NumPy: Statistical calculations, array operations

  • CSV/JSON: Data format transformation and validation

Contributing to Features#

Students and developers can contribute by:

  1. Documentation Improvements: Fix typos, add examples, clarify technical concepts

  2. Bug Fixes: Address issues in the GitHub issue tracker

  3. Feature Enhancements: Propose and implement new accountability metrics

  4. Test Coverage: Write unit and integration tests to improve code quality

  5. Accessibility Audits: Test with screen readers and keyboard navigation

  6. Internationalization: Add support for Spanish language for California’s multilingual families

See the Developer Guide for detailed contribution guidelines.

Design Patterns Implemented#

This project demonstrates several important software design patterns:

Structural Patterns:

  • Composite Pattern: Nested component hierarchy (Feature → Component)

  • Decorator Pattern: Higher-order components for accessibility features

  • Facade Pattern: Simplified API interfaces for complex CDE data structures

Behavioral Patterns:

  • Observer Pattern: React state management and re-rendering on data changes

  • Strategy Pattern: Pluggable algorithms for different metric calculations

  • Template Method: Reusable component templates with customizable behavior

Architectural Patterns:

  • Model-View-Controller (MVC): Separation of data, presentation, and business logic

  • Repository Pattern: Data access abstraction layer

  • Dependency Injection: Loose coupling through FastAPI’s dependency system

Feature List#

Epics & Features

External Resources#

California Education Policy:

Technical Standards:

Educational Technology: